@webex/webex-core 3.0.0-beta.2 → 3.0.0-beta.21

package/dist/index.js

@@ -1,378 +1,302 @@
 "use strict";
 
 var _typeof = require("@babel/runtime-corejs2/helpers/typeof");
-
 var _WeakMap = require("@babel/runtime-corejs2/core-js/weak-map");
-
 var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
-
 var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
-
 var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
-
 _Object$defineProperty(exports, "__esModule", {
   value: true
 });
-
 _Object$defineProperty(exports, "AuthInterceptor", {
   enumerable: true,
   get: function get() {
     return _auth.default;
   }
 });
-
 _Object$defineProperty(exports, "Batcher", {
   enumerable: true,
   get: function get() {
     return _batcher.default;
   }
 });
-
 _Object$defineProperty(exports, "Credentials", {
   enumerable: true,
   get: function get() {
     return _credentials.Credentials;
   }
 });
-
 _Object$defineProperty(exports, "DefaultOptionsInterceptor", {
   enumerable: true,
   get: function get() {
     return _defaultOptions.default;
   }
 });
-
 _Object$defineProperty(exports, "EmbargoInterceptor", {
   enumerable: true,
   get: function get() {
     return _embargo.default;
   }
 });
-
 _Object$defineProperty(exports, "MemoryStoreAdapter", {
   enumerable: true,
   get: function get() {
     return _storage.MemoryStoreAdapter;
   }
 });
-
 _Object$defineProperty(exports, "NetworkTimingInterceptor", {
   enumerable: true,
   get: function get() {
     return _networkTiming.default;
   }
 });
-
 _Object$defineProperty(exports, "NotFoundError", {
   enumerable: true,
   get: function get() {
     return _storage.NotFoundError;
   }
 });
-
 _Object$defineProperty(exports, "Page", {
   enumerable: true,
   get: function get() {
     return _page.default;
   }
 });
-
 _Object$defineProperty(exports, "PayloadTransformerInterceptor", {
   enumerable: true,
   get: function get() {
     return _payloadTransformer.default;
   }
 });
-
 _Object$defineProperty(exports, "RateLimitInterceptor", {
   enumerable: true,
   get: function get() {
     return _rateLimit.default;
   }
 });
-
 _Object$defineProperty(exports, "RedirectInterceptor", {
   enumerable: true,
   get: function get() {
     return _redirect.default;
   }
 });
-
 _Object$defineProperty(exports, "RequestEventInterceptor", {
   enumerable: true,
   get: function get() {
     return _requestEvent.default;
   }
 });
-
 _Object$defineProperty(exports, "RequestLoggerInterceptor", {
   enumerable: true,
   get: function get() {
     return _requestLogger.default;
   }
 });
-
 _Object$defineProperty(exports, "RequestTimingInterceptor", {
   enumerable: true,
   get: function get() {
     return _requestTiming.default;
   }
 });
-
 _Object$defineProperty(exports, "ResponseLoggerInterceptor", {
   enumerable: true,
   get: function get() {
     return _responseLogger.default;
   }
 });
-
 _Object$defineProperty(exports, "ServerErrorInterceptor", {
   enumerable: true,
   get: function get() {
     return _services.ServerErrorInterceptor;
   }
 });
-
 _Object$defineProperty(exports, "ServiceCatalog", {
   enumerable: true,
   get: function get() {
     return _services.ServiceCatalog;
   }
 });
-
 _Object$defineProperty(exports, "ServiceHost", {
   enumerable: true,
   get: function get() {
     return _services.ServiceHost;
   }
 });
-
 _Object$defineProperty(exports, "ServiceInterceptor", {
   enumerable: true,
   get: function get() {
     return _services.ServiceInterceptor;
   }
 });
-
 _Object$defineProperty(exports, "ServiceRegistry", {
   enumerable: true,
   get: function get() {
     return _services.ServiceRegistry;
   }
 });
-
 _Object$defineProperty(exports, "ServiceState", {
   enumerable: true,
   get: function get() {
     return _services.ServiceState;
   }
 });
-
 _Object$defineProperty(exports, "ServiceUrl", {
   enumerable: true,
   get: function get() {
     return _services.ServiceUrl;
   }
 });
-
 _Object$defineProperty(exports, "Services", {
   enumerable: true,
   get: function get() {
     return _services.Services;
   }
 });
-
 _Object$defineProperty(exports, "StatelessWebexPlugin", {
   enumerable: true,
   get: function get() {
     return _statelessWebexPlugin.default;
   }
 });
-
 _Object$defineProperty(exports, "StorageError", {
   enumerable: true,
   get: function get() {
     return _storage.StorageError;
   }
 });
-
 _Object$defineProperty(exports, "Token", {
   enumerable: true,
   get: function get() {
     return _credentials.Token;
   }
 });
-
 _Object$defineProperty(exports, "UserAgentInterceptor", {
   enumerable: true,
   get: function get() {
     return _userAgent.default;
   }
 });
-
 _Object$defineProperty(exports, "WebexHttpError", {
   enumerable: true,
   get: function get() {
     return _webexHttpError.default;
   }
 });
-
 _Object$defineProperty(exports, "WebexPlugin", {
   enumerable: true,
   get: function get() {
     return _webexPlugin.default;
   }
 });
-
 _Object$defineProperty(exports, "WebexTrackingIdInterceptor", {
   enumerable: true,
   get: function get() {
     return _webexTrackingId.default;
   }
 });
-
 _Object$defineProperty(exports, "WebexUserAgentInterceptor", {
   enumerable: true,
   get: function get() {
     return _webexUserAgent.default;
   }
 });
-
 _Object$defineProperty(exports, "config", {
   enumerable: true,
   get: function get() {
     return _config.default;
   }
 });
-
 _Object$defineProperty(exports, "default", {
   enumerable: true,
   get: function get() {
     return _webexCore.default;
   }
 });
-
 _Object$defineProperty(exports, "filterScope", {
   enumerable: true,
   get: function get() {
     return _credentials.filterScope;
   }
 });
-
 _Object$defineProperty(exports, "grantErrors", {
   enumerable: true,
   get: function get() {
     return _credentials.grantErrors;
   }
 });
-
 _Object$defineProperty(exports, "makeWebexPluginStore", {
   enumerable: true,
   get: function get() {
     return _storage.makeWebexPluginStore;
   }
 });
-
 _Object$defineProperty(exports, "makeWebexStore", {
   enumerable: true,
   get: function get() {
     return _storage.makeWebexStore;
   }
 });
-
 _Object$defineProperty(exports, "persist", {
   enumerable: true,
   get: function get() {
     return _storage.persist;
   }
 });
-
 _Object$defineProperty(exports, "registerInternalPlugin", {
   enumerable: true,
   get: function get() {
     return _webexCore.registerInternalPlugin;
   }
 });
-
 _Object$defineProperty(exports, "registerPlugin", {
   enumerable: true,
   get: function get() {
     return _webexCore.registerPlugin;
   }
 });
-
 _Object$defineProperty(exports, "serviceConstants", {
   enumerable: true,
   get: function get() {
     return _services.constants;
   }
 });
-
 _Object$defineProperty(exports, "sortScope", {
   enumerable: true,
   get: function get() {
     return _credentials.sortScope;
   }
 });
-
 _Object$defineProperty(exports, "waitForValue", {
   enumerable: true,
   get: function get() {
     return _storage.waitForValue;
   }
 });
-
 require("./plugins/logger");
-
 var _credentials = require("./lib/credentials");
-
 var _services = require("./lib/services");
-
 var _storage = require("./lib/storage");
-
 var _webexCore = _interopRequireWildcard(require("./webex-core"));
-
 var _webexHttpError = _interopRequireDefault(require("./lib/webex-http-error"));
-
 var _statelessWebexPlugin = _interopRequireDefault(require("./lib/stateless-webex-plugin"));
-
 var _webexPlugin = _interopRequireDefault(require("./lib/webex-plugin"));
-
 var _auth = _interopRequireDefault(require("./interceptors/auth"));
-
 var _networkTiming = _interopRequireDefault(require("./interceptors/network-timing"));
-
 var _payloadTransformer = _interopRequireDefault(require("./interceptors/payload-transformer"));
-
 var _redirect = _interopRequireDefault(require("./interceptors/redirect"));
-
 var _responseLogger = _interopRequireDefault(require("./interceptors/response-logger"));
-
 var _requestEvent = _interopRequireDefault(require("./interceptors/request-event"));
-
 var _requestLogger = _interopRequireDefault(require("./interceptors/request-logger"));
-
 var _requestTiming = _interopRequireDefault(require("./interceptors/request-timing"));
-
 var _userAgent = _interopRequireDefault(require("./interceptors/user-agent"));
-
 var _webexTrackingId = _interopRequireDefault(require("./interceptors/webex-tracking-id"));
-
 var _webexUserAgent = _interopRequireDefault(require("./interceptors/webex-user-agent"));
-
 var _rateLimit = _interopRequireDefault(require("./interceptors/rate-limit"));
-
 var _embargo = _interopRequireDefault(require("./interceptors/embargo"));
-
 var _defaultOptions = _interopRequireDefault(require("./interceptors/default-options"));
-
 var _batcher = _interopRequireDefault(require("./lib/batcher"));
-
 var _page = _interopRequireDefault(require("./lib/page"));
-
 var _config = _interopRequireDefault(require("./config"));
-
 function _getRequireWildcardCache(nodeInterop) { if (typeof _WeakMap !== "function") return null; var cacheBabelInterop = new _WeakMap(); var cacheNodeInterop = new _WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = _Object$defineProperty && _Object$getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? _Object$getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { _Object$defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["index.js"],"sourcesContent":["/*!\n * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.\n *\n * Services is currently a part of webex-core due to how the contents of\n * the original internal-plugin-services needed to be accessed when webex-core\n * is initialized. As a plugin outside of webex-core, it would initialize after\n * credentials, causing all requests prior to its initialization to fail\n * federation requirements, and instead send requests to the environmentally-\n * assigned urls.\n */\n\nimport './plugins/logger';\nimport './lib/credentials';\nimport './lib/services';\n\nexport {\n  Credentials,\n  filterScope,\n  grantErrors,\n  sortScope,\n  Token\n} from './lib/credentials';\n\nexport {\n  constants as serviceConstants,\n  ServiceCatalog,\n  ServiceRegistry,\n  ServiceState,\n  ServiceInterceptor,\n  ServerErrorInterceptor,\n  Services,\n  ServiceHost,\n  ServiceUrl\n} from './lib/services';\n\nexport {\n  makeWebexStore,\n  makeWebexPluginStore,\n  MemoryStoreAdapter,\n  NotFoundError,\n  persist,\n  StorageError,\n  waitForValue\n} from './lib/storage';\n\nexport {\n  default,\n  registerPlugin,\n  registerInternalPlugin\n} from './webex-core';\n\nexport {default as WebexHttpError} from './lib/webex-http-error';\nexport {default as StatelessWebexPlugin} from './lib/stateless-webex-plugin';\nexport {default as WebexPlugin} from './lib/webex-plugin';\nexport {default as AuthInterceptor} from './interceptors/auth';\nexport {default as NetworkTimingInterceptor} from './interceptors/network-timing';\nexport {default as PayloadTransformerInterceptor} from './interceptors/payload-transformer';\nexport {default as RedirectInterceptor} from './interceptors/redirect';\nexport {default as ResponseLoggerInterceptor} from './interceptors/response-logger';\nexport {default as RequestEventInterceptor} from './interceptors/request-event';\nexport {default as RequestLoggerInterceptor} from './interceptors/request-logger';\nexport {default as RequestTimingInterceptor} from './interceptors/request-timing';\nexport {default as UserAgentInterceptor} from './interceptors/user-agent';\nexport {default as WebexTrackingIdInterceptor} from './interceptors/webex-tracking-id';\nexport {default as WebexUserAgentInterceptor} from './interceptors/webex-user-agent';\nexport {default as RateLimitInterceptor} from './interceptors/rate-limit';\nexport {default as EmbargoInterceptor} from './interceptors/embargo';\nexport {default as DefaultOptionsInterceptor} from './interceptors/default-options';\n\nexport {default as Batcher} from './lib/batcher';\nexport {default as Page} from './lib/page';\nexport {default as config} from './config';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWA;;AACA;;AACA;;AAsBA;;AAUA;;AAMA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAEA;;AACA;;AACA"}
+{"version":3,"names":[],"sources":["index.js"],"sourcesContent":["/*!\n * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.\n *\n * Services is currently a part of webex-core due to how the contents of\n * the original internal-plugin-services needed to be accessed when webex-core\n * is initialized. As a plugin outside of webex-core, it would initialize after\n * credentials, causing all requests prior to its initialization to fail\n * federation requirements, and instead send requests to the environmentally-\n * assigned urls.\n */\n\nimport './plugins/logger';\nimport './lib/credentials';\nimport './lib/services';\n\nexport {Credentials, filterScope, grantErrors, sortScope, Token} from './lib/credentials';\n\nexport {\n  constants as serviceConstants,\n  ServiceCatalog,\n  ServiceRegistry,\n  ServiceState,\n  ServiceInterceptor,\n  ServerErrorInterceptor,\n  Services,\n  ServiceHost,\n  ServiceUrl,\n} from './lib/services';\n\nexport {\n  makeWebexStore,\n  makeWebexPluginStore,\n  MemoryStoreAdapter,\n  NotFoundError,\n  persist,\n  StorageError,\n  waitForValue,\n} from './lib/storage';\n\nexport {default, registerPlugin, registerInternalPlugin} from './webex-core';\n\nexport {default as WebexHttpError} from './lib/webex-http-error';\nexport {default as StatelessWebexPlugin} from './lib/stateless-webex-plugin';\nexport {default as WebexPlugin} from './lib/webex-plugin';\nexport {default as AuthInterceptor} from './interceptors/auth';\nexport {default as NetworkTimingInterceptor} from './interceptors/network-timing';\nexport {default as PayloadTransformerInterceptor} from './interceptors/payload-transformer';\nexport {default as RedirectInterceptor} from './interceptors/redirect';\nexport {default as ResponseLoggerInterceptor} from './interceptors/response-logger';\nexport {default as RequestEventInterceptor} from './interceptors/request-event';\nexport {default as RequestLoggerInterceptor} from './interceptors/request-logger';\nexport {default as RequestTimingInterceptor} from './interceptors/request-timing';\nexport {default as UserAgentInterceptor} from './interceptors/user-agent';\nexport {default as WebexTrackingIdInterceptor} from './interceptors/webex-tracking-id';\nexport {default as WebexUserAgentInterceptor} from './interceptors/webex-user-agent';\nexport {default as RateLimitInterceptor} from './interceptors/rate-limit';\nexport {default as EmbargoInterceptor} from './interceptors/embargo';\nexport {default as DefaultOptionsInterceptor} from './interceptors/default-options';\n\nexport {default as Batcher} from './lib/batcher';\nexport {default as Page} from './lib/page';\nexport {default as config} from './config';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWA;AACA;AACA;AAgBA;AAUA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AAA2C;AAAA"}

package/dist/interceptors/auth.js

@@ -1,50 +1,32 @@
 "use strict";
 
 var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
-
 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 _deleteProperty = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/reflect/delete-property"));
-
 var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
-
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
-
 var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
-
 var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/inherits"));
-
 var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/possibleConstructorReturn"));
-
 var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/getPrototypeOf"));
-
 var _httpCore = require("@webex/http-core");
-
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = _Reflect$construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
-
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !_Reflect$construct) return false; if (_Reflect$construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
 /**
  * @class
  */
 var AuthInterceptor = /*#__PURE__*/function (_Interceptor) {
   (0, _inherits2.default)(AuthInterceptor, _Interceptor);
-
   var _super = _createSuper(AuthInterceptor);
-
   function AuthInterceptor() {
     (0, _classCallCheck2.default)(this, AuthInterceptor);
     return _super.apply(this, arguments);
   }
-
   (0, _createClass2.default)(AuthInterceptor, [{
     key: "onRequest",
     value:
@@ -55,78 +37,73 @@ var AuthInterceptor = /*#__PURE__*/function (_Interceptor) {
      */
     function onRequest(options) {
       var _this = this;
+      options.headers = options.headers || {};
 
-      options.headers = options.headers || {}; // If Authorizations is already set, don't overwrite it
-
+      // If Authorizations is already set, don't overwrite it
       if ('authorization' in options.headers || 'auth' in options) {
         // If Authorization is set to null, false, or undefined, delete it to
         // prevent a CORS preflight.
         if (!options.headers.authorization) {
           (0, _deleteProperty.default)(options.headers, 'authorization');
         }
-
         return _promise.default.resolve(options);
       }
-
       return this.requiresCredentials(options).then(function (requires) {
         if (!requires) {
           return options;
         }
-
         return _this.webex.credentials.getUserToken().then(function (token) {
           options.headers.authorization = token.toString();
           return options;
         });
       });
     }
+
     /**
      * Determines if the provided options object needs an authorization header.
      *
      * @param {Object} options
      * @returns {Promise<boolean>}
      */
-
   }, {
     key: "requiresCredentials",
     value: function requiresCredentials(options) {
       var _this2 = this;
-
       // Validate that authorization is necessary.
       if (options.addAuthHeader === false) {
         return _promise.default.resolve(false);
-      } // Validate that the services plugin has been loaded before proceeding.
-
+      }
 
+      // Validate that the services plugin has been loaded before proceeding.
       if (!this.webex.internal.services) {
         return _promise.default.resolve(false);
-      } // Destructure webex instance to isolate services plugin.
-
+      }
 
-      var services = this.webex.internal.services; // Store the current service details if available and destructure details.
+      // Destructure webex instance to isolate services plugin.
+      var services = this.webex.internal.services;
 
+      // Store the current service details if available and destructure details.
       var details = services.getServiceFromUrl(options.uri || '');
-
       var _ref = details || {},
-          name = _ref.name;
-
+        name = _ref.name;
       var resource = options.resource,
-          uri = options.uri;
-      var service = options.service || options.api; // Unique validation for the u2c service.
+        uri = options.uri;
+      var service = options.service || options.api;
 
+      // Unique validation for the u2c service.
       if (service && service === 'u2c' || name && name === 'u2c') {
         if (resource && resource.includes('limited') || uri && uri.includes('limited')) {
           return _promise.default.resolve(false);
         }
-
         return _promise.default.resolve(true);
-      } // Validate that the allowed domains can be utilized.
-
+      }
 
+      // Validate that the allowed domains can be utilized.
       if (services.validateDomains && services.hasAllowedDomains() && uri && services.isAllowedDomainUrl(uri)) {
         return _promise.default.resolve(true);
-      } // Perform an additional validation in case the service does not exist yet.
-
+      }
 
+      // Perform an additional validation in case the service does not exist yet.
       return services.waitForService({
         name: service,
         url: uri
@@ -134,52 +111,47 @@ var AuthInterceptor = /*#__PURE__*/function (_Interceptor) {
         // Validate that the url exists in the catalog.
         if (services.getServiceFromUrl(detectedUrl)) {
           return true;
-        } // Return false to indicate authentication is not required.
-
+        }
 
+        // Return false to indicate authentication is not required.
         return false;
       }).catch(function (error) {
         _this2.webex.logger.warn('auth-interceptor: failed to validate service exists in catalog', error);
-
         return false;
       });
     }
+
     /**
      * @see {@link Interceptor#onResponseError}
      * @param {Object} options
      * @param {Error} reason
      * @returns {Object}
      */
-
   }, {
     key: "onResponseError",
     value: function onResponseError(options, reason) {
       var _this3 = this;
-
       return this.shouldAttemptReauth(reason, options).then(function (shouldAttemptReauth) {
         if (shouldAttemptReauth) {
           _this3.webex.logger.info('auth: received 401, attempting to reauthenticate');
-
           if (reason.options.headers) {
             (0, _deleteProperty.default)(reason.options.headers, 'authorization');
           }
-
           if (_this3.webex.credentials.canRefresh) {
             return _this3.webex.credentials.refresh().then(function () {
               return _this3.replay(options);
             });
           }
         }
-
         return _promise.default.reject(reason);
       });
     }
+
     /**
      * Replays the request
      * @param {Object} options
      * @returns {Object}
      */
-
   }, {
     key: "replay",
     value: function replay(options) {
@@ -188,15 +160,14 @@ var AuthInterceptor = /*#__PURE__*/function (_Interceptor) {
       } else {
         options.replayCount = 1;
       }
-
       if (options.replayCount > this.webex.config.maxAuthenticationReplays) {
         this.webex.logger.error("auth: failed after ".concat(this.webex.config.maxAuthenticationReplays, " replay attempts"));
         return _promise.default.reject(new Error("Failed after ".concat(this.webex.config.maxAuthenticationReplays, " replay attempts")));
       }
-
       this.webex.logger.info("auth: replaying request ".concat(options.replayCount, " time"));
       return this.webex.request(options);
     }
+
     /**
      * Indicates whether or not the current request should refresh its access
      * token in event of a 401
@@ -204,18 +175,15 @@ var AuthInterceptor = /*#__PURE__*/function (_Interceptor) {
      * @param {Object} options
      * @returns {Promise<boolean>}
      */
-
   }, {
     key: "shouldAttemptReauth",
     value: function shouldAttemptReauth(reason, options) {
       if (options && options.shouldRefreshAccessToken === false) {
         return _promise.default.resolve(false);
       }
-
       if (reason.statusCode === 401) {
         return _promise.default.resolve(true);
       }
-
       return _promise.default.resolve(false);
     }
   }], [{
@@ -232,6 +200,5 @@ var AuthInterceptor = /*#__PURE__*/function (_Interceptor) {
   }]);
   return AuthInterceptor;
 }(_httpCore.Interceptor);
-
 exports.default = AuthInterceptor;
 //# sourceMappingURL=auth.js.map