@webex/plugin-meetings 3.0.0-beta.4 → 3.0.0-beta.400

package/src/locus-info/{parser.js → parser.ts}

@@ -1,8 +1,30 @@
 import {difference} from 'lodash';
 
-import SimpleQueue from '../common/queue';
+import SortedQueue from '../common/queue';
 import LoggerProxy from '../common/logs/logger-proxy';
 
+import Metrics from '../metrics';
+import BEHAVIORAL_METRICS from '../metrics/constants';
+
+const 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
+const OOO_DELTA_WAIT_TIME = 10000; // [ms] minimum wait time before we do a sync if we get out-of-order deltas
+const OOO_DELTA_WAIT_TIME_RANDOM_DELAY = 5000; // [ms] max random delay added to OOO_DELTA_WAIT_TIME
+
+type LocusDeltaDto = {
+  url: string;
+  baseSequence: {
+    rangeStart: number;
+    rangeEnd: number;
+    entries: number[];
+  };
+  sequence: {
+    rangeStart: number;
+    rangeEnd: number;
+    entries: number[];
+  };
+  syncUrl: string;
+};
+
 /**
  * Locus Delta Parser
  * @private
@@ -10,11 +32,11 @@ import LoggerProxy from '../common/logs/logger-proxy';
  */
 export default class Parser {
   // processing status
-  static status = {
-    IDLE: 'IDLE',
-    PAUSED: 'PAUSED',
-    WORKING: 'WORKING'
-  };
+  status:
+    | 'IDLE' // not doing anything
+    | 'PAUSED' // paused, because we are doing a sync
+    | 'WORKING' // processing a delta event
+    | 'BLOCKED'; // received an out-of-order delta, so waiting for the missing one
 
   // loci comparison states
   static loci = {
@@ -24,20 +46,61 @@ export default class Parser {
     DESYNC: 'DESYNC',
     USE_INCOMING: 'USE_INCOMING',
     USE_CURRENT: 'USE_CURRENT',
-    ERROR: 'ERROR'
+    WAIT: 'WAIT',
+    ERROR: 'ERROR',
+    LOCUS_URL_CHANGED: 'LOCUS_URL_CHANGED',
   };
 
+  queue: SortedQueue<LocusDeltaDto>;
+  workingCopy: any;
+  syncTimer?: ReturnType<typeof setTimeout>;
 
   /**
    * @constructs Parser
    */
   constructor() {
-    this.queue = new SimpleQueue();
-    this.status = Parser.status.IDLE;
+    const deltaCompareFunc = (left: LocusDeltaDto, right: LocusDeltaDto) => {
+      const {LT, GT} = Parser.loci;
+      const {extractComparisonState: extract} = Parser;
+
+      if (Parser.isSequenceEmpty(left)) {
+        return -1;
+      }
+      if (Parser.isSequenceEmpty(right)) {
+        return 1;
+      }
+      const result = extract(Parser.compareSequence(left.baseSequence, right.baseSequence));
+
+      if (result === LT) {
+        return -1;
+      }
+      if (result === GT) {
+        return 1;
+      }
+
+      return 0;
+    };
+
+    this.queue = new SortedQueue<LocusDeltaDto>(deltaCompareFunc);
+    this.status = 'IDLE';
     this.onDeltaAction = null;
     this.workingCopy = null;
+    this.syncTimer = undefined;
   }
 
+  /**
+   * Returns a debug string representing a locus delta - useful for logging
+   *
+   * @param {LocusDeltaDto} locus Locus delta
+   * @returns {string}
+   */
+  static locus2string(locus: LocusDeltaDto) {
+    if (!locus.sequence?.entries) {
+      return 'invalid';
+    }
+
+    return locus.sequence.entries.length ? `seq=${locus.sequence.entries.at(-1)}` : 'empty';
+  }
 
   /**
    * Checks if two sequences overlap in time,
@@ -65,7 +128,6 @@ export default class Parser {
     return comparison;
   }
 
-
   /**
    * Checks if two sequences have unequal ranges.
    * Chooses sequence with most larger range.
@@ -91,8 +153,7 @@ export default class Parser {
       else if (currentTotalRange < incomingTotalRange) {
         // choose right side (incoming)
         comparison = `${Parser.loci.LT}:UR002`;
-      }
-      else {
+      } else {
         // with no unique entries and with ranges either absent or
         // of the same size, the sequences are considered equal.
         comparison = `${Parser.loci.EQ}:UR003`;
@@ -102,7 +163,6 @@ export default class Parser {
     return comparison;
   }
 
-
   /**
    * Checks if either sequences has unique entries.
    * Entries are considered unique if they do not overlap
@@ -131,7 +191,6 @@ export default class Parser {
     return comparison;
   }
 
-
   /**
    * Checks both Locus Delta objects to see if they are
    * out of sync with one another. If so sends a DESYNC
@@ -161,12 +220,10 @@ export default class Parser {
 
       // send DESYNC to server
       comparison = `${Parser.loci.DESYNC}:OOS001:${debugInfo}`;
-    }
-    else if (currentUniqueMin > incomingUniqueMin) {
+    } else if (currentUniqueMin > incomingUniqueMin) {
       // choose left side (current)
       comparison = `${Parser.loci.GT}:OOS002`;
-    }
-    else {
+    } else {
       // choose right side (incoming)
       comparison = `${Parser.loci.LT}:OOS003`;
     }
@@ -174,7 +231,6 @@ export default class Parser {
     return comparison;
   }
 
-
   /**
    * Compares two loci to determine which one contains the most recent state
    * @instance
@@ -188,7 +244,6 @@ export default class Parser {
     const {extractComparisonState: extract} = Parser;
     const {packComparisonResult: pack} = Parser;
 
-
     if (isSequenceEmpty(current) || isSequenceEmpty(incoming)) {
       return pack(Parser.loci.USE_INCOMING, 'C001');
     }
@@ -203,7 +258,6 @@ export default class Parser {
     return pack(action, result);
   }
 
-
   /**
    * Compares two loci sequences (with delta params) and indicates what action
    * to take.
@@ -214,21 +268,26 @@ export default class Parser {
    * @private
    * @returns {string} loci comparison state
    */
-  static compareDelta(current, incoming) {
-    const {
-      LT, GT, EQ, DESYNC, USE_INCOMING
-    } = Parser.loci;
+  private static compareDelta(current, incoming) {
+    const {LT, GT, EQ, DESYNC, USE_INCOMING, WAIT, LOCUS_URL_CHANGED} = Parser.loci;
+
     const {extractComparisonState: extract} = Parser;
     const {packComparisonResult: pack} = Parser;
 
     const result = Parser.compareSequence(current.sequence, incoming.sequence);
     let comparison = extract(result);
 
-
     if (comparison !== LT) {
       return pack(Parser.compareToAction(comparison), result);
     }
 
+    if (incoming.url !== current.url) {
+      // when moving to/from a breakout session, the locus URL will change and also
+      // the baseSequence, making incoming and current incomparable, so use a
+      // unique comparison state
+      return pack(LOCUS_URL_CHANGED, result);
+    }
+
     comparison = Parser.compareSequence(current.sequence, incoming.baseSequence);
 
     switch (extract(comparison)) {
@@ -237,6 +296,21 @@ export default class Parser {
         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;
+
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.LOCUS_DELTA_OUT_OF_ORDER, {
+            stack: new Error().stack,
+          });
+        }
+        break;
       default:
         comparison = DESYNC;
     }
@@ -244,6 +318,48 @@ export default class Parser {
     return pack(comparison, result);
   }
 
+  /**
+   * Compares Locus sequences - it should be called only for full Locus DTOs, not deltas
+   *
+   * @param {Types~Locus} current Current working copy
+   * @param {Types~Locus} incomingFullDto New Full Locus DTO
+   * @returns {string} either Parser.loci.USE_INCOMING or Parser.loci.USE_CURRENT
+   */
+  static 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;
+  }
+
+  /**
+   * 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
+   */
+  isNewFullLocus(incomingFullDto) {
+    if (!Parser.isLoci(incomingFullDto)) {
+      LoggerProxy.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;
+    }
+
+    const comparisonResult = Parser.compareFullDtoSequence(this.workingCopy, incomingFullDto);
+
+    return comparisonResult === Parser.loci.USE_INCOMING;
+  }
 
   /**
    * Compares Locus sequences
@@ -255,8 +371,8 @@ export default class Parser {
     // Locus sequence comparison rules in order of priority.
     // https://sqbu-github.cisco.com/WebExSquared/cloud-apps/wiki/Locus-Sequence-Comparison-Algorithm
 
-    const local = Parser.getMetaData(current);
-    const delta = Parser.getMetaData(incoming);
+    const local: any = Parser.getMetaData(current);
+    const delta: any = Parser.getMetaData(incoming);
 
     // update loci metadata
     local.unique = Parser.getUniqueSequences(local, delta);
@@ -268,7 +384,7 @@ export default class Parser {
       Parser.checkSequenceOverlap,
       Parser.checkUnequalRanges,
       Parser.checkForUniqueEntries,
-      Parser.checkIfOutOfSync
+      Parser.checkIfOutOfSync,
     ];
 
     for (const rule of rules) {
@@ -287,16 +403,13 @@ export default class Parser {
     return Parser.loci.ERROR;
   }
 
-
   /**
    * Transates the result of a sequence comparison into an intended behavior
    * @param {string} result
    * @returns {string} Locus comparison action
    */
-  static compareToAction(result) {
-    const {
-      DESYNC, EQ, ERROR, GT, LT, USE_CURRENT, USE_INCOMING
-    } = Parser.loci;
+  static compareToAction(result: string) {
+    const {DESYNC, EQ, ERROR, GT, LT, USE_CURRENT, USE_INCOMING} = Parser.loci;
 
     let action = ERROR;
 
@@ -312,23 +425,23 @@ export default class Parser {
         action = DESYNC;
         break;
       default:
-        LoggerProxy.logger.info(`Locus-info:parser#compareToAction --> Error: ${result} is not a recognized sequence comparison result.`);
+        LoggerProxy.logger.info(
+          `Locus-info:parser#compareToAction --> Error: ${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.
    */
-  static extractComparisonState(lociComparisonResult) {
+  static extractComparisonState(lociComparisonResult: string) {
     return lociComparisonResult.split(':')[0];
   }
 
-
   /**
    * @typedef {object} LociMetadata
    * @property {number} start - Starting sequence number
@@ -345,7 +458,7 @@ export default class Parser {
    * @param {Array.<number>} sequence Locus delta sequence
    * @returns {LociMetadata} Locus Delta Metadata
    */
-  static getMetaData(sequence) {
+  static getMetaData(sequence: any) {
     const {entries} = sequence;
     const first = entries[0];
     const last = entries.slice(-1)[0];
@@ -365,11 +478,10 @@ export default class Parser {
       // Grab last entry if exist else default to rangeEnd
       max: last || end,
       // keep reference to actual sequence entries
-      entries
+      entries,
     };
   }
 
-
   /**
    * Compares two Locus delta objects and notes unique
    * values contained within baseLoci.
@@ -377,17 +489,14 @@ export default class Parser {
    * @param {LociMetadata} otherLoci
    * @returns {Array.<number>} List of unique sequences
    */
-  static getUniqueSequences(baseLoci, otherLoci) {
-    const diff = difference(
-      baseLoci.entries,
-      otherLoci.entries
-    );
+  static getUniqueSequences(baseLoci: any, otherLoci: any) {
+    const diff: any = difference(baseLoci.entries, otherLoci.entries);
+
     const {start, end} = otherLoci;
 
     return Parser.getNumbersOutOfRange(diff, start, end);
   }
 
-
   /**
    * Returns an array of numbers outside of a given range.
    * @param {Array.<number>} list Array to filter
@@ -395,7 +504,7 @@ export default class Parser {
    * @param {number} rangeEnd End of range
    * @returns {Array.<number>} Array of numbers sorted ASC
    */
-  static getNumbersOutOfRange(list, rangeStart, rangeEnd) {
+  static getNumbersOutOfRange(list: Array<number>, rangeStart: number, rangeEnd: number) {
     // Collect all numbers if number is outside of specified range
     const output = list.filter((num) => num < rangeStart || num > rangeEnd);
 
@@ -403,7 +512,6 @@ export default class Parser {
     return output.sort((a, b) => a - b);
   }
 
-
   /**
    * Checks if newLoci or workingCopy is invalid.
    * @param {Types~Locus} newLoci
@@ -411,23 +519,23 @@ export default class Parser {
    */
   isValidLocus(newLoci) {
     let isValid = false;
-    const {IDLE} = Parser.status;
     const {isLoci} = Parser;
-    const setStatus = (status) => { this.status = status; };
 
     // one or both objects are not locus delta events
     if (!isLoci(this.workingCopy) || !isLoci(newLoci)) {
-      setStatus(IDLE);
-      LoggerProxy.logger.info('Locus-info:parser#processDeltaEvent --> Ignoring non-locus object. workingCopy:', this.workingCopy, 'newLoci:', newLoci);
-    }
-    else {
+      LoggerProxy.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
@@ -441,7 +549,6 @@ export default class Parser {
     return hasEmptyEntries && hasEmptyRange;
   }
 
-
   /**
    * Determines if an object has basic
    * structure of a locus object.
@@ -452,8 +559,7 @@ export default class Parser {
     if (!loci || !loci.sequence) {
       return false;
     }
-    const hasProp = (prop) =>
-      Object.prototype.hasOwnProperty.call(loci.sequence, prop);
+    const hasProp = (prop) => Object.prototype.hasOwnProperty.call(loci.sequence, prop);
 
     if (hasProp('rangeStart') && hasProp('rangeEnd')) {
       return true;
@@ -468,22 +574,28 @@ export default class Parser {
    * @returns {undefined}
    */
   nextEvent() {
-    if (this.status === Parser.status.PAUSED) {
+    if (this.status === 'PAUSED') {
       LoggerProxy.logger.info('Locus-info:parser#nextEvent --> Locus parser paused.');
 
       return;
     }
 
+    if (this.status === 'BLOCKED') {
+      LoggerProxy.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;
+    } else {
+      this.status = 'IDLE';
     }
   }
 
-
   /**
    * Function handler for delta actions,
    * is set by instance callee.
@@ -491,9 +603,8 @@ export default class Parser {
    * @param {Types~Locus} locus Locus delta
    * @returns {undefined}
    */
-  // eslint-disable-next-line no-unused-vars
-  onDeltaAction(action, locus) {}
-
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  onDeltaAction(action: string, locus) {}
 
   /**
    * Event handler for locus delta events
@@ -503,37 +614,86 @@ export default class Parser {
   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();
+    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}
    */
-  static packComparisonResult(newData, oldData) {
+  static packComparisonResult(newData: string, oldData: string) {
     return `${newData}:${oldData}`;
   }
 
-
   /**
    * Pause locus processing
    * @returns {undefined}
    */
   pause() {
-    this.status = Parser.status.PAUSED;
+    this.status = 'PAUSED';
     LoggerProxy.logger.info('Locus-info:parser#pause --> Locus parser paused.');
   }
 
+  /**
+   * Triggers a sync with Locus
+   *
+   * @param {string} reason used just for logging
+   * @returns {undefined}
+   */
+  private triggerSync(reason: string) {
+    LoggerProxy.logger.info(`Locus-info:parser#triggerSync --> doing sync, reason: ${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}
+   */
+  private startSyncTimer() {
+    if (this.syncTimer === undefined) {
+      const timeout = OOO_DELTA_WAIT_TIME + Math.random() * OOO_DELTA_WAIT_TIME_RANDOM_DELAY;
+
+      this.syncTimer = setTimeout(() => {
+        this.syncTimer = undefined;
+        this.triggerSync('timer expired, blocked on out-of-order delta');
+      }, timeout);
+    }
+  }
+
+  /**
+   * Stops the timer for triggering a sync
+   *
+   * @returns {undefined}
+   */
+  private stopSyncTimer() {
+    if (this.syncTimer !== undefined) {
+      clearTimeout(this.syncTimer);
+      this.syncTimer = undefined;
+    }
+  }
 
   /**
    * Processes next locus delta in the queue,
@@ -542,11 +702,13 @@ export default class Parser {
    * @returns {undefined}
    */
   processDeltaEvent() {
-    const {DESYNC, USE_INCOMING} = Parser.loci;
+    const {DESYNC, USE_INCOMING, WAIT, LOCUS_URL_CHANGED} = Parser.loci;
     const {extractComparisonState: extract} = Parser;
     const newLoci = this.queue.dequeue();
 
     if (!this.isValidLocus(newLoci)) {
+      this.nextEvent();
+
       return;
     }
 
@@ -557,51 +719,88 @@ export default class Parser {
     // for full debugging.
     LoggerProxy.logger.debug(`Locus-info:parser#processDeltaEvent --> Locus Debug: ${result}`);
 
-    if (lociComparison === DESYNC) {
-      // wait for desync response
-      this.pause();
+    let needToWait = false;
+
+    switch (lociComparison) {
+      case DESYNC:
+        // wait for desync response
+        this.pause();
+        break;
+
+      case USE_INCOMING:
+      case LOCUS_URL_CHANGED:
+        // update working copy for future comparisons.
+        // Note: The working copy of parser gets updated in .onFullLocus()
+        // and here when USE_INCOMING or LOCUS_URL_CHANGED locus.
+        this.workingCopy = newLoci;
+        break;
+
+      case 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;
+        break;
+
+      default:
+        break;
     }
-    else if (lociComparison === USE_INCOMING) {
-      // update working copy for future comparisons.
-      // Note: The working copy of parser gets updated in .onFullLocus()
-      // and here when USE_INCOMING locus.
-      this.workingCopy = newLoci;
+
+    if (needToWait) {
+      this.status = 'BLOCKED';
+      this.startSyncTimer();
+    } else {
+      this.stopSyncTimer();
+
+      if (this.status === 'BLOCKED') {
+        // we are not blocked anymore
+        this.status = 'WORKING';
+
+        LoggerProxy.logger.info(
+          `Locus-info:parser#processDeltaEvent --> received delta that we were waiting for ${Parser.locus2string(
+            newLoci
+          )}, not blocked anymore`
+        );
+      }
     }
 
     if (this.onDeltaAction) {
-      LoggerProxy.logger.info(`Locus-info:parser#processDeltaEvent --> Locus Delta Action: ${lociComparison}`);
-      this.onDeltaAction.call(this, lociComparison, newLoci);
+      LoggerProxy.logger.info(
+        `Locus-info:parser#processDeltaEvent --> Locus Delta ${Parser.locus2string(
+          newLoci
+        )}, Action: ${lociComparison}`
+      );
+
+      this.onDeltaAction(lociComparison, newLoci);
     }
 
     this.nextEvent();
   }
 
-
   /**
    * Resume from a paused state
    * @returns {undefined}
    */
   resume() {
     LoggerProxy.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
    */
-  static getDebugMessage(debugCode, comparison) {
+  static getDebugMessage(debugCode: string, comparison: string) {
     // removes extra spaces from multiline string
     const mStr = (strings) => strings.join('').replace(/\s{2,}/g, ' ');
 
     const resolutionMap = {
       EQ: `${Parser.loci.LT}: is equal (current == incoming).`,
       LT: `${Parser.loci.LT}: choose right side (incoming).`,
-      GT: `${Parser.loci.GT}: choose left side (current).`
+      GT: `${Parser.loci.GT}: choose left side (current).`,
     };
 
     const debugMap = {
@@ -609,28 +808,28 @@ export default class Parser {
         title: 'checkSequenceOverlap-001',
         description: mStr`Occurs if earliest working copy sequence is more \
             recent than last incoming sequence.`,
-        logic: 'current.min > incoming.max'
+        logic: 'current.min > incoming.max',
       },
 
       SO002: {
         title: 'checkSequenceOverlap-002',
         description: mStr`Occurs if last working copy sequence is before the \
           earliest incoming sequence.`,
-        logic: 'current.max < incoming.min'
+        logic: 'current.max < incoming.min',
       },
 
       UR001: {
         title: 'checkUnequalRanges-001',
         description: mStr`Occurs if there are no unique values for both loci, \
           and the current working copy loci has a larger range.`,
-        logic: 'currentTotalRange > incomingTotalRange'
+        logic: 'currentTotalRange > incomingTotalRange',
       },
 
       UR002: {
         title: 'checkUnequalRanges-002',
         description: mStr`Occurs if there are no unique values for both loci, \
           and the incoming delta loci has a larger range.`,
-        logic: 'currentTotalRange < incomingTotalRange'
+        logic: 'currentTotalRange < incomingTotalRange',
       },
 
       UR003: {
@@ -638,7 +837,7 @@ export default class Parser {
         description: mStr`Occurs if there are no unique values for both loci, \
           and with ranges either absent or of the same size, the sequences \
           are considered equal.`,
-        logic: 'currentTotalRange == incomingTotalRange'
+        logic: 'currentTotalRange == incomingTotalRange',
       },
 
       UE001: {
@@ -646,7 +845,7 @@ export default class Parser {
         description: mStr`Occurs if current loci has unique entries and \
           incoming does not. Entries are considered unique if they \
           do not overlap with other Loci sequences or range values.`,
-        logic: 'currentIsUnique && !incomingIsUnique'
+        logic: 'currentIsUnique && !incomingIsUnique',
       },
 
       UE002: {
@@ -654,7 +853,7 @@ export default class Parser {
         description: mStr`Occurs if current has no unique entries but \
           incoming does. Entries are considered unique if they \
           do not overlap with other Loci sequences or range values.`,
-        logic: '!currentIsUnique && incomingIsUnique'
+        logic: '!currentIsUnique && incomingIsUnique',
       },
 
       OOS001: {
@@ -663,7 +862,7 @@ export default class Parser {
           if the current loci unique entries overlap the total range of the \
           incoming sequence, or if the incoming unique entries overlap \
           the total range of current sequence.`,
-        logic: 'neitherSeqHasRange || currentUniqOverlap || incomingUniqOverlap'
+        logic: 'neitherSeqHasRange || currentUniqOverlap || incomingUniqOverlap',
       },
 
       OOS002: {
@@ -671,15 +870,15 @@ export default class Parser {
         description: mStr`Occurs if the minimum value from sequences that are \
           unique to the current loci is greater than the minimum value from \
           sequences that are unique to the incoming loci.`,
-        logic: 'currentUniqueMin > incomingUniqueMin'
+        logic: 'currentUniqueMin > incomingUniqueMin',
       },
 
       OOS003: {
         title: 'checkIfOutOfSync-003',
         description: mStr`Occurs if none of the comparison rules applied. \
           It is a catch all.`,
-        logic: 'else (catch all)'
-      }
+        logic: 'else (catch all)',
+      },
     };
 
     const debugObj = debugMap[debugCode];