@webex/plugin-meetings 3.0.0-beta.15 → 3.0.0-beta.151

package/dist/reachability/index.js

@@ -1,52 +1,33 @@
 "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 _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
-
 var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
-
 var _values = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/values"));
-
 var _now = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/date/now"));
-
 var _keys = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/keys"));
-
 var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
-
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/assign"));
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/toConsumableArray"));
-
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
-
 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 _uniq2 = _interopRequireDefault(require("lodash/uniq"));
-
 var _loggerProxy = _interopRequireDefault(require("../common/logs/logger-proxy"));
-
 var _constants = require("../constants");
-
 var _request = _interopRequireDefault(require("./request"));
-
 var DEFAULT_TIMEOUT = 3000;
 var VIDEO_MESH_TIMEOUT = 1000;
 /**
  * @class Reachability
  * @export
  */
-
 var Reachability = /*#__PURE__*/function () {
   /**
    * Creates an instance of Reachability.
@@ -55,10 +36,12 @@ var Reachability = /*#__PURE__*/function () {
    */
   function Reachability(webex) {
     (0, _classCallCheck2.default)(this, Reachability);
+    (0, _defineProperty2.default)(this, "namespace", _constants.REACHABILITY.namespace);
     (0, _defineProperty2.default)(this, "webex", void 0);
     (0, _defineProperty2.default)(this, "reachabilityRequest", void 0);
     (0, _defineProperty2.default)(this, "clusterLatencyResults", void 0);
     this.webex = webex;
+
     /**
      * internal request object for the server
      * @instance
@@ -66,8 +49,8 @@ var Reachability = /*#__PURE__*/function () {
      * @private
      * @memberof Reachability
      */
-
     this.reachabilityRequest = new _request.default(this.webex);
+
     /**
      * internal object of clusters latency results
      * @instance
@@ -75,9 +58,9 @@ var Reachability = /*#__PURE__*/function () {
      * @private
      * @memberof Reachability
      */
-
     this.clusterLatencyResults = {};
   }
+
   /**
    * fetches reachability data
    * @returns {Object} reachability data
@@ -85,73 +68,57 @@ var Reachability = /*#__PURE__*/function () {
    * @async
    * @memberof Reachability
    */
-
-
   (0, _createClass2.default)(Reachability, [{
     key: "gatherReachability",
     value: function () {
       var _gatherReachability = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
-        var _window, _window$localStorage;
-
-        var clusters, results;
+        var _yield$this$reachabil, clusters, joinCookie, results;
         return _regenerator.default.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                this.setup(); // Remove stored reachability results to ensure no stale data
-
-                if (!((_window = window) !== null && _window !== void 0 && (_window$localStorage = _window.localStorage) !== null && _window$localStorage !== void 0 && _window$localStorage.removeItem)) {
-                  _context.next = 5;
-                  break;
-                }
-
-                window.localStorage.removeItem(_constants.REACHABILITY.localStorage);
-                _context.next = 7;
-                break;
-
-              case 5:
-                _loggerProxy.default.logger.error('Reachability:index#gatherReachability --> Error in accessing LocalStorage.');
-
-                return _context.abrupt("return", {});
-
-              case 7:
-                _context.prev = 7;
-                _context.next = 10;
-                return this.reachabilityRequest.getClusters();
-
-              case 10:
-                clusters = _context.sent;
-                _context.next = 13;
-                return this.performReachabilityCheck(clusters);
-
-              case 13:
-                results = _context.sent;
-                window.localStorage.setItem(_constants.REACHABILITY.localStorage, (0, _stringify.default)(results));
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              this.setup();
 
-                _loggerProxy.default.logger.log('Reachability:index#gatherReachability --> Reachability checks completed');
-
-                return _context.abrupt("return", results);
-
-              case 19:
-                _context.prev = 19;
-                _context.t0 = _context["catch"](7);
-
-                _loggerProxy.default.logger.error("Reachability:index#gatherReachability --> Error in calling getClusters(): ".concat(_context.t0));
-
-                return _context.abrupt("return", {});
-
-              case 23:
-              case "end":
-                return _context.stop();
-            }
+              // Remove stored reachability results to ensure no stale data
+              // @ts-ignore
+              _context.next = 3;
+              return this.webex.boundedStorage.del(this.namespace, _constants.REACHABILITY.localStorageResult);
+            case 3:
+              _context.next = 5;
+              return this.webex.boundedStorage.del(this.namespace, _constants.REACHABILITY.localStorageJoinCookie);
+            case 5:
+              _context.prev = 5;
+              _context.next = 8;
+              return this.reachabilityRequest.getClusters();
+            case 8:
+              _yield$this$reachabil = _context.sent;
+              clusters = _yield$this$reachabil.clusters;
+              joinCookie = _yield$this$reachabil.joinCookie;
+              _context.next = 13;
+              return this.performReachabilityCheck(clusters);
+            case 13:
+              results = _context.sent;
+              _context.next = 16;
+              return this.webex.boundedStorage.put(this.namespace, _constants.REACHABILITY.localStorageResult, (0, _stringify.default)(results));
+            case 16:
+              _context.next = 18;
+              return this.webex.boundedStorage.put(this.namespace, _constants.REACHABILITY.localStorageJoinCookie, (0, _stringify.default)(joinCookie));
+            case 18:
+              _loggerProxy.default.logger.log('Reachability:index#gatherReachability --> Reachability checks completed');
+              return _context.abrupt("return", results);
+            case 22:
+              _context.prev = 22;
+              _context.t0 = _context["catch"](5);
+              _loggerProxy.default.logger.error("Reachability:index#gatherReachability --> Error in calling getClusters(): ".concat(_context.t0));
+              return _context.abrupt("return", {});
+            case 26:
+            case "end":
+              return _context.stop();
           }
-        }, _callee, this, [[7, 19]]);
+        }, _callee, this, [[5, 22]]);
       }));
-
       function gatherReachability() {
         return _gatherReachability.apply(this, arguments);
       }
-
       return gatherReachability;
     }()
     /**
@@ -160,28 +127,42 @@ var Reachability = /*#__PURE__*/function () {
      * @public
      * @memberof Reachability
      */
-
   }, {
     key: "isAnyClusterReachable",
-    value: function isAnyClusterReachable() {
-      var reachable = false;
-      var reachabilityData = window.localStorage.getItem(_constants.REACHABILITY.localStorage);
-
-      if (reachabilityData) {
-        try {
-          var reachabilityResults = JSON.parse(reachabilityData);
-          reachable = (0, _values.default)(reachabilityResults).some(function (result) {
-            var _result$udp, _result$tcp;
-
-            return ((_result$udp = result.udp) === null || _result$udp === void 0 ? void 0 : _result$udp.reachable) === 'true' || ((_result$tcp = result.tcp) === null || _result$tcp === void 0 ? void 0 : _result$tcp.reachable) === 'true';
-          });
-        } catch (e) {
-          _loggerProxy.default.logger.error("Roap:request#attachReachabilityData --> Error in parsing reachability data: ".concat(e));
-        }
+    value: function () {
+      var _isAnyClusterReachable = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+        var reachable, reachabilityData, reachabilityResults;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              reachable = false; // @ts-ignore
+              _context2.next = 3;
+              return this.webex.boundedStorage.get(this.namespace, _constants.REACHABILITY.localStorageResult).catch(function () {});
+            case 3:
+              reachabilityData = _context2.sent;
+              if (reachabilityData) {
+                try {
+                  reachabilityResults = JSON.parse(reachabilityData);
+                  reachable = (0, _values.default)(reachabilityResults).some(function (result) {
+                    var _result$udp, _result$tcp;
+                    return ((_result$udp = result.udp) === null || _result$udp === void 0 ? void 0 : _result$udp.reachable) === 'true' || ((_result$tcp = result.tcp) === null || _result$tcp === void 0 ? void 0 : _result$tcp.reachable) === 'true';
+                  });
+                } catch (e) {
+                  _loggerProxy.default.logger.error("Roap:request#attachReachabilityData --> Error in parsing reachability data: ".concat(e));
+                }
+              }
+              return _context2.abrupt("return", reachable);
+            case 6:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function isAnyClusterReachable() {
+        return _isAnyClusterReachable.apply(this, arguments);
       }
-
-      return reachable;
-    }
+      return isAnyClusterReachable;
+    }()
     /**
      * Generate peerConnection config settings
      * @param {object} cluster
@@ -189,7 +170,6 @@ var Reachability = /*#__PURE__*/function () {
      * @private
      * @memberof Reachability
      */
-
   }, {
     key: "buildPeerConnectionConfig",
     value: function buildPeerConnectionConfig(cluster) {
@@ -206,6 +186,7 @@ var Reachability = /*#__PURE__*/function () {
         iceTransportPolicy: 'all'
       };
     }
+
     /**
      * Creates an RTCPeerConnection
      * @param {object} cluster
@@ -213,24 +194,23 @@ var Reachability = /*#__PURE__*/function () {
      * @private
      * @memberof Reachability
      */
-
   }, {
     key: "createPeerConnection",
     value: function createPeerConnection(cluster) {
       var key = cluster.key,
-          config = cluster.config;
-
+        config = cluster.config;
       try {
-        var peerConnection = new window.RTCPeerConnection(config); // @ts-ignore
+        var peerConnection = new window.RTCPeerConnection(config);
 
+        // @ts-ignore
         peerConnection.key = key;
         return peerConnection;
       } catch (peerConnectionError) {
         _loggerProxy.default.logger.log("Reachability:index#createPeerConnection --> Error creating peerConnection: ".concat(peerConnectionError));
-
         return null;
       }
     }
+
     /**
      * Gets total elapsed time
      * @param {RTCPeerConnection} peerConnection
@@ -238,7 +218,6 @@ var Reachability = /*#__PURE__*/function () {
      * @private
      * @memberof Reachability
      */
-
   }, {
     key: "getElapsedTime",
     value: function getElapsedTime(peerConnection) {
@@ -246,6 +225,7 @@ var Reachability = /*#__PURE__*/function () {
       delete peerConnection.begin;
       return (0, _now.default)() - startTime;
     }
+
     /**
      * creates offer and generates localSDP
      * @param {object} clusterList cluster List
@@ -253,66 +233,59 @@ var Reachability = /*#__PURE__*/function () {
      * @private
      * @memberof Reachability
      */
-
   }, {
     key: "getLocalSDPForClusters",
     value: function getLocalSDPForClusters(clusterList) {
       var _this = this;
-
       var clusters = (0, _toConsumableArray2.default)((0, _keys.default)(clusterList));
       clusters = clusters.map( /*#__PURE__*/function () {
-        var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(key) {
+        var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(key) {
           var cluster, config, peerConnection, description;
-          return _regenerator.default.wrap(function _callee2$(_context2) {
-            while (1) {
-              switch (_context2.prev = _context2.next) {
-                case 0:
-                  cluster = clusterList[key];
-                  config = _this.buildPeerConnectionConfig(cluster);
-                  peerConnection = _this.createPeerConnection({
-                    key: key,
-                    config: config
-                  });
-                  _context2.next = 5;
-                  return peerConnection.createOffer({
-                    offerToReceiveAudio: true
-                  });
-
-                case 5:
-                  description = _context2.sent;
-                  // @ts-ignore
-                  peerConnection.begin = (0, _now.default)();
-                  peerConnection.setLocalDescription(description);
-                  return _context2.abrupt("return", _this.iceGatheringState(peerConnection, cluster.isVideoMesh ? VIDEO_MESH_TIMEOUT : DEFAULT_TIMEOUT).catch(function (iceGatheringStateError) {
-                    _loggerProxy.default.logger.log("Reachability:index#getLocalSDPForClusters --> Error in getLocalSDP : ".concat(iceGatheringStateError));
-                  }));
-
-                case 9:
-                case "end":
-                  return _context2.stop();
-              }
+          return _regenerator.default.wrap(function _callee3$(_context3) {
+            while (1) switch (_context3.prev = _context3.next) {
+              case 0:
+                cluster = clusterList[key];
+                config = _this.buildPeerConnectionConfig(cluster);
+                peerConnection = _this.createPeerConnection({
+                  key: key,
+                  config: config
+                });
+                _context3.next = 5;
+                return peerConnection.createOffer({
+                  offerToReceiveAudio: true
+                });
+              case 5:
+                description = _context3.sent;
+                // @ts-ignore
+                peerConnection.begin = (0, _now.default)();
+                peerConnection.setLocalDescription(description);
+                return _context3.abrupt("return", _this.iceGatheringState(peerConnection, cluster.isVideoMesh ? VIDEO_MESH_TIMEOUT : DEFAULT_TIMEOUT).catch(function (iceGatheringStateError) {
+                  _loggerProxy.default.logger.log("Reachability:index#getLocalSDPForClusters --> Error in getLocalSDP : ".concat(iceGatheringStateError));
+                }));
+              case 9:
+              case "end":
+                return _context3.stop();
             }
-          }, _callee2);
+          }, _callee3);
         }));
-
         return function (_x) {
           return _ref.apply(this, arguments);
         };
       }());
       return _promise.default.all(clusters).then(this.parseIceResultsToReachabilityResults).then(function (reachabilityLatencyResults) {
-        _this.logUnreachableClusters(); // return results
-
+        _this.logUnreachableClusters();
 
+        // return results
         return reachabilityLatencyResults;
       });
     }
+
     /**
      * Get list of all unreachable clusters
      * @returns {array} Unreachable clusters
      * @private
      * @memberof Reachability
      */
-
   }, {
     key: "getUnreachablClusters",
     value: function getUnreachablClusters() {
@@ -320,13 +293,13 @@ var Reachability = /*#__PURE__*/function () {
       var clusters = this.clusterLatencyResults;
       (0, _keys.default)(clusters).forEach(function (key) {
         var cluster = clusters[key];
-
         if (cluster.unreachable && !cluster.reachable) {
           unreachableList.push(key);
         }
       });
       return unreachableList;
     }
+
     /**
      * Attach an event handler for the icegatheringstatechange
      * event and measure latency.
@@ -335,25 +308,23 @@ var Reachability = /*#__PURE__*/function () {
      * @private
      * @memberof Reachability
      */
-
   }, {
     key: "handleIceGatheringStateChange",
     value: function handleIceGatheringStateChange(peerConnection) {
       var _this2 = this;
-
       peerConnection.onicegatheringstatechange = function () {
         var COMPLETE = _constants.ICE_GATHERING_STATE.COMPLETE;
-
         if (peerConnection.iceConnectionState === COMPLETE) {
-          var elapsed = _this2.getElapsedTime(peerConnection); // @ts-ignore
-
-
-          _loggerProxy.default.logger.log("Reachability:index#onIceGatheringStateChange --> Successfully pinged ".concat(peerConnection.key, ":"), elapsed);
+          var elapsed = _this2.getElapsedTime(peerConnection);
 
+          // @ts-ignore
+          _loggerProxy.default.logger.log( // @ts-ignore
+          "Reachability:index#onIceGatheringStateChange --> Successfully pinged ".concat(peerConnection.key, ":"), elapsed);
           _this2.setLatencyAndClose(peerConnection, elapsed);
         }
       };
     }
+
     /**
      * Attach an event handler for the icecandidate
      * event and measure latency.
@@ -362,25 +333,23 @@ var Reachability = /*#__PURE__*/function () {
      * @private
      * @memberof Reachability
      */
-
   }, {
     key: "handleOnIceCandidate",
     value: function handleOnIceCandidate(peerConnection) {
       var _this3 = this;
-
       peerConnection.onicecandidate = function (e) {
         var SERVER_REFLEXIVE = 'srflx';
-
         if (e.candidate && String(e.candidate.type).toLowerCase() === SERVER_REFLEXIVE) {
-          var elapsed = _this3.getElapsedTime(peerConnection); // @ts-ignore
-
-
-          _loggerProxy.default.logger.log("Reachability:index#onIceCandidate --> Successfully pinged ".concat(peerConnection.key, ":"), elapsed);
-
+          var elapsed = _this3.getElapsedTime(peerConnection);
+          _loggerProxy.default.logger.log( // @ts-ignore
+          "Reachability:index#onIceCandidate --> Successfully pinged ".concat(peerConnection.key, ":"), elapsed);
+          // order is important
+          _this3.addPublicIP(peerConnection, e.candidate.address);
           _this3.setLatencyAndClose(peerConnection, elapsed);
         }
       };
     }
+
     /**
      * An event handler on an RTCPeerConnection when the state of the ICE
      * candidate gathering process changes. Used to measure connection
@@ -390,22 +359,19 @@ var Reachability = /*#__PURE__*/function () {
      * @param {number} timeout
      * @returns {Promise}
      */
-
   }, {
     key: "iceGatheringState",
     value: function iceGatheringState(peerConnection, timeout) {
       var _this4 = this;
-
       var ELAPSED = 'elapsed';
       return new _promise.default(function (resolve) {
         var peerConnectionProxy = new window.Proxy(peerConnection, {
+          // eslint-disable-next-line require-jsdoc
           get: function get(target, property) {
             var targetMember = target[property];
-
             if (typeof targetMember === 'function') {
               return targetMember.bind(target);
             }
-
             return targetMember;
           },
           set: function set(target, property, value) {
@@ -414,38 +380,42 @@ var Reachability = /*#__PURE__*/function () {
               // @ts-ignore
               resolve({
                 clusterId: peerConnection.key,
+                publicIPs: target.publicIPs,
                 elapsed: value
               });
               return true;
-            } // pass thru
-
+            }
 
+            // pass thru
             return window.Reflect.set(target, property, value);
           }
-        }); // Using peerConnection proxy so handle functions below
-        // won't be coupled to our promise implementation
+        });
 
+        // Using peerConnection proxy so handle functions below
+        // won't be coupled to our promise implementation
         _this4.handleIceGatheringStateChange(peerConnectionProxy);
+        _this4.handleOnIceCandidate(peerConnectionProxy);
 
-        _this4.handleOnIceCandidate(peerConnectionProxy); // Set maximum timeout
-
-
+        // Set maximum timeout
         window.setTimeout(function () {
-          var CLOSED = _constants.CONNECTION_STATE.CLOSED; // Close any open peerConnections
+          var CLOSED = _constants.CONNECTION_STATE.CLOSED;
 
+          // Close any open peerConnections
           if (peerConnectionProxy.connectionState !== CLOSED) {
+            // order is important
+            _this4.addPublicIP(peerConnectionProxy, null);
             _this4.setLatencyAndClose(peerConnectionProxy, null);
           }
         }, timeout);
       });
     }
+
     /**
      * Make a log of unreachable clusters.
      * @returns {undefined}
      * @private
      * @memberof Reachability
      */
-
   }, {
     key: "logUnreachableClusters",
     value: function logUnreachableClusters() {
@@ -454,34 +424,38 @@ var Reachability = /*#__PURE__*/function () {
         _loggerProxy.default.logger.log("Reachability:index#logUnreachableClusters --> No ice candidate for ".concat(cluster, "."));
       });
     }
+
     /**
      * Calculates time to establish connection
-     * @param {array} iceResults iceResults
+     * @param {Array<ICECandidateResult>} iceResults iceResults
      * @returns {object} reachabilityMap
-     * @private
+     * @protected
      * @memberof Reachability
      */
-
   }, {
     key: "parseIceResultsToReachabilityResults",
     value: function parseIceResultsToReachabilityResults(iceResults) {
       var reachabilityMap = {};
       iceResults.forEach(function (_ref2) {
         var clusterId = _ref2.clusterId,
-            elapsed = _ref2.elapsed;
-        var latencyResult;
-
-        if (elapsed === null) {
-          latencyResult = {
+          elapsed = _ref2.elapsed,
+          publicIPs = _ref2.publicIPs;
+        var latencyResult = {};
+        if (!elapsed) {
+          (0, _assign.default)(latencyResult, {
             reachable: 'false'
-          };
+          });
         } else {
-          latencyResult = {
+          (0, _assign.default)(latencyResult, {
             reachable: 'true',
             latencyInMilliseconds: elapsed.toString()
-          };
+          });
+        }
+        if (publicIPs) {
+          (0, _assign.default)(latencyResult, {
+            clientMediaIPs: publicIPs
+          });
         }
-
         reachabilityMap[clusterId] = {
           udp: latencyResult,
           tcp: latencyResult
@@ -489,6 +463,7 @@ var Reachability = /*#__PURE__*/function () {
       });
       return reachabilityMap;
     }
+
     /**
      * fetches reachability data
      * @param {object} clusterList
@@ -496,33 +471,54 @@ var Reachability = /*#__PURE__*/function () {
      * @private
      * @memberof Reachability
      */
-
   }, {
     key: "performReachabilityCheck",
     value: function performReachabilityCheck(clusterList) {
       var _this5 = this;
-
       if (!clusterList || !(0, _keys.default)(clusterList).length) {
         return _promise.default.resolve({});
       }
-
       return new _promise.default(function (resolve) {
         _this5.getLocalSDPForClusters(clusterList).then(function (localSDPData) {
           if (!localSDPData || !(0, _keys.default)(localSDPData).length) {
             // TODO: handle the error condition properly and try retry
             _loggerProxy.default.logger.log('Reachability:index#performReachabilityCheck --> Local SDP is empty or has missing elements..returning');
-
             resolve({});
           } else {
             resolve(localSDPData);
           }
         }).catch(function (error) {
           _loggerProxy.default.logger.error("Reachability:index#performReachabilityCheck --> Error in getLocalSDPForClusters: ".concat(error));
-
           resolve({});
         });
       });
     }
+
+    /**
+     * Adds public IP (client media IPs)
+     * @param {RTCPeerConnection} peerConnection
+     * @param {string} publicIP
+     * @returns {void}
+     */
+  }, {
+    key: "addPublicIP",
+    value: function addPublicIP(peerConnection, publicIP) {
+      var modifiedPeerConnection = peerConnection;
+      var CLOSED = _constants.CONNECTION_STATE.CLOSED;
+      if (modifiedPeerConnection.connectionState === CLOSED) {
+        _loggerProxy.default.logger.log("Reachability:index#addPublicIP --> Attempting to set publicIP of ".concat(publicIP, " on closed peerConnection."));
+      }
+      if (publicIP) {
+        if (modifiedPeerConnection.publicIPs) {
+          modifiedPeerConnection.publicIPs.push(publicIP);
+        } else {
+          modifiedPeerConnection.publicIPs = [publicIP];
+        }
+      } else {
+        modifiedPeerConnection.publicIPs = null;
+      }
+    }
+
     /**
      * Records latency and closes the peerConnection
      * @param {RTCPeerConnection} peerConnection
@@ -531,42 +527,38 @@ var Reachability = /*#__PURE__*/function () {
      * @private
      * @memberof Reachability
      */
-
   }, {
     key: "setLatencyAndClose",
     value: function setLatencyAndClose(peerConnection, elapsed) {
       var _intialState;
-
       var REACHABLE = 'reachable';
       var UNREACHABLE = 'unreachable';
-      var CLOSED = _constants.CONNECTION_STATE.CLOSED; // @ts-ignore
-
+      var CLOSED = _constants.CONNECTION_STATE.CLOSED;
+      // @ts-ignore
       var key = peerConnection.key;
       var resultKey = elapsed === null ? UNREACHABLE : REACHABLE;
       var intialState = (_intialState = {}, (0, _defineProperty2.default)(_intialState, REACHABLE, 0), (0, _defineProperty2.default)(_intialState, UNREACHABLE, 0), _intialState);
-
       if (peerConnection.connectionState === CLOSED) {
         _loggerProxy.default.logger.log("Reachability:index#setLatencyAndClose --> Attempting to set latency of ".concat(elapsed, " on closed peerConnection."));
-
         return;
       }
-
       this.clusterLatencyResults[key] = this.clusterLatencyResults[key] || intialState;
-      this.clusterLatencyResults[key][resultKey] += 1; // Set to null in case this fired from
-      // an event other than onIceCandidate
+      this.clusterLatencyResults[key][resultKey] += 1;
 
+      // Set to null in case this fired from
+      // an event other than onIceCandidate
       peerConnection.onicecandidate = null;
-      peerConnection.close(); // @ts-ignore
-
+      peerConnection.close();
+      // @ts-ignore
       peerConnection.elapsed = elapsed;
     }
+
     /**
      * utility function
      * @returns {undefined}
      * @private
      * @memberof Reachability
      */
-
   }, {
     key: "setup",
     value: function setup() {
@@ -575,6 +567,5 @@ var Reachability = /*#__PURE__*/function () {
   }]);
   return Reachability;
 }();
-
 exports.default = Reachability;
 //# sourceMappingURL=index.js.map