intelicoreact 1.3.19 → 1.3.21

package/dist/Classes/RESTAPI/partials/CredentialsProcessing.js

@@ -1,213 +1,461 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _outerDependencies = _interopRequireDefault(require("./_outerDependencies"));
+
 var _utils = require("./_utils");
-const {
-  jwt
-} = _outerDependencies.default;
-class CredentialsProcessing {
-  constructor(settings) {
-    const {
-      credentialsProcessing
-    } = settings;
-    const {
-      //? Для корректной работы установки токенов в запросы от API
-      //? нужно передавать методы getCredentials и getHeadersForAuthorize
-      getCredentials,
-      getHeadersForAuthorize,
-      //? На вход получит токен, должна вернуть объект для коструктора Headers
-
-      //? Так же опционально можно передавать
-      importCredentials,
-      //? если он передается, то он будет применяться к выводу от вызова getCredentials
-      saveCredentials,
-      //? можно будет найти в объекте credentialsProcessing, чтобы использовать кастомными методами
-
-      //! Либо вызов getCredentials, либо цепочка вызовов importCredentials(getCredentials())
-      //! должна возвращать требуемую классом структуру
-      //! Класс требует структуры
-      //!   - { token }, если флоу рефреш токена НЕ используется
-      //!   - { token, refreshToken, expires }, если используется флоу рефреш токена
-
-      // *********
-
-      //? Подключает флоу рефреша токенов
-      isUseRefreshTokensPropcessing = false,
-      //! Для корректной работы флоу рефреша токенов передача метода saveCredentials становится ОБЯЗАТЕЛЬНОЙ
-
-      //? Так же для корректной работы флоу рефреша токенов нужно
-      //?   - либо
-      refreshCredentials,
-      //! метод должен возвращать такую же структуру как и метод getCredentials,
-      //? на вход получит текущие креды, к выходу будет применен importCredentials, если этот метод передавался
-      //?   - либо
-      REFRESH_TOKEN_PATH,
-      //! REFRESH_TOKEN_PATH передается ПОЛНОСТЬЮ (глобальная адресация)!
-      CODES_USING_THE_REFRESH_ATTEMPT,
-      //? указывает по каким кодам ответа триггериться рефреш, массив чисел
-
-      //? Опционально
-      REFRESH_TOKEN_FLAG = 'refreshTokenFlag',
-      INTERVAL_FOR_CHECKING_TOKEN_UPDATE = 50,
-      // ms
-      callbackAfterRejectRefresh
-    } = credentialsProcessing || {};
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+var jwt = _outerDependencies.default.jwt;
+
+var CredentialsProcessing = /*#__PURE__*/function () {
+  function CredentialsProcessing(settings) {
+    (0, _classCallCheck2.default)(this, CredentialsProcessing);
+    var credentialsProcessing = settings.credentialsProcessing;
+
+    var _ref = credentialsProcessing || {},
+        getCredentials = _ref.getCredentials,
+        getHeadersForAuthorize = _ref.getHeadersForAuthorize,
+        importCredentials = _ref.importCredentials,
+        saveCredentials = _ref.saveCredentials,
+        _ref$isUseRefreshToke = _ref.isUseRefreshTokensPropcessing,
+        isUseRefreshTokensPropcessing = _ref$isUseRefreshToke === void 0 ? false : _ref$isUseRefreshToke,
+        refreshCredentials = _ref.refreshCredentials,
+        REFRESH_TOKEN_PATH = _ref.REFRESH_TOKEN_PATH,
+        CODES_USING_THE_REFRESH_ATTEMPT = _ref.CODES_USING_THE_REFRESH_ATTEMPT,
+        _ref$REFRESH_TOKEN_FL = _ref.REFRESH_TOKEN_FLAG,
+        REFRESH_TOKEN_FLAG = _ref$REFRESH_TOKEN_FL === void 0 ? 'refreshTokenFlag' : _ref$REFRESH_TOKEN_FL,
+        _ref$INTERVAL_FOR_CHE = _ref.INTERVAL_FOR_CHECKING_TOKEN_UPDATE,
+        INTERVAL_FOR_CHECKING_TOKEN_UPDATE = _ref$INTERVAL_FOR_CHE === void 0 ? 50 : _ref$INTERVAL_FOR_CHE,
+        callbackAfterRejectRefresh = _ref.callbackAfterRejectRefresh;
+
     if (typeof getCredentials !== 'function') throw new Error('No getCredentials method [CredentialsProcessing]');
+
     if (typeof getHeadersForAuthorize !== 'function') {
       throw new Error('No getHeadersForAuthorize method [CredentialsProcessing]');
     }
+
     if (importCredentials && typeof importCredentials !== 'function') {
       throw new Error('Bad importCredentials method [CredentialsProcessing]');
     }
+
     this.isUseRefreshTokensPropcessing = isUseRefreshTokensPropcessing;
     this.DEFAULT_CREDENTIALS = {};
     this.getCredentialsByOuter = getCredentials;
     this.getHeadersForAuthorize = getHeadersForAuthorize;
-    this.importCredentials = importCredentials;
+    this.importCredentials = importCredentials; //? Если метод передан или если не передан, но включен флоу обновления токенов (тогда saveCredentials обязателен)
 
-    //? Если метод передан или если не передан, но включен флоу обновления токенов (тогда saveCredentials обязателен)
     if (saveCredentials || isUseRefreshTokensPropcessing) {
       if (typeof saveCredentials !== 'function') throw new Error('No saveCredentials method [CredentialsProcessing]');else this.saveCredentials = saveCredentials;
     }
+
     if (isUseRefreshTokensPropcessing) {
       if (typeof refreshCredentials === 'function') this.refreshCredentialsByOuter = refreshCredentials;else {
         if (typeof this.refreshCredentialsByOuter === 'function' && typeof REFRESH_TOKEN_PATH !== 'string') {
           throw new Error('No REFRESH_TOKEN_PATH [CredentialsProcessing]');
         }
+
         this.REFRESH_TOKEN_PATH = REFRESH_TOKEN_PATH;
       }
+
       if (!Array.isArray(CODES_USING_THE_REFRESH_ATTEMPT)) {
         throw new Error('No CODES_USING_THE_REFRESH_ATTEMPT [CredentialsProcessing]');
       }
-      if (!CODES_USING_THE_REFRESH_ATTEMPT.every(i => typeof i === 'number')) {
+
+      if (!CODES_USING_THE_REFRESH_ATTEMPT.every(function (i) {
+        return typeof i === 'number';
+      })) {
         throw new Error('Invalid format of CODES_USING_THE_REFRESH_ATTEMPT elements [CredentialsProcessing]');
       }
+
       if (typeof REFRESH_TOKEN_FLAG !== 'string') throw new Error('Bad REFRESH_TOKEN_FLAG [CredentialsProcessing]');
+
       if (typeof INTERVAL_FOR_CHECKING_TOKEN_UPDATE !== 'number') {
         throw new Error('Bad INTERVAL_FOR_CHECKING_TOKEN_UPDATE [CredentialsProcessing]');
       }
+
       if (typeof INTERVAL_FOR_CHECKING_TOKEN_UPDATE !== 'number') {
         throw new Error('Bad INTERVAL_FOR_CHECKING_TOKEN_UPDATE [CredentialsProcessing]');
       }
+
       if (callbackAfterRejectRefresh && typeof callbackAfterRejectRefresh !== 'function') {
         throw new Error('Bad INTERVAL_FOR_CHECKING_TOKEN_UPDATE [CredentialsProcessing]');
       }
+
       this.CODES_USING_THE_REFRESH_ATTEMPT = CODES_USING_THE_REFRESH_ATTEMPT;
       this.REFRESH_TOKEN_FLAG = REFRESH_TOKEN_FLAG;
       this.INTERVAL_FOR_CHECKING_TOKEN_UPDATE = INTERVAL_FOR_CHECKING_TOKEN_UPDATE;
       if (callbackAfterRejectRefresh) this.callbackAfterRejectRefresh = callbackAfterRejectRefresh;
     }
   }
-  getIsTokenStartRefresh() {
-    return localStorage.getItem(this.REFRESH_TOKEN_FLAG);
-  }
-  setIsTokenStartRefresh() {
-    localStorage.setItem(this.REFRESH_TOKEN_FLAG, true);
-  }
-  removeIsTokenStartRefresh() {
-    localStorage.removeItem(this.REFRESH_TOKEN_FLAG);
-  }
-  async getCredentials(isCatchCallbackProcess, callback) {
-    let credentials = await this.getCredentialsByOuter();
-    if (typeof this.importCredentials === 'function') credentials = await this.importCredentials(credentials);
-    if (!(0, _utils.getIsOnlyAnObject)(credentials)) credentials = {};
-    const token = credentials.token || null;
-    if (token && !isCatchCallbackProcess) {
-      let decoded;
-      try {
-        decoded = jwt.decode(token);
-      } catch {
-        decoded = null;
-      }
-      const currentTime = Date.now() / 1000;
-      if (decoded !== null && +decoded.exp < currentTime) credentials = {
-        ...credentials,
-        isNeedRefresh: true
-      };
+
+  (0, _createClass2.default)(CredentialsProcessing, [{
+    key: "getIsTokenStartRefresh",
+    value: function getIsTokenStartRefresh() {
+      return localStorage.getItem(this.REFRESH_TOKEN_FLAG);
     }
-    if (callback) await callback({
-      ...credentials,
-      isCatchCallbackProcess
-    });
-    return {
-      ...credentials,
-      isCatchCallbackProcess
-    };
-  }
-  async refreshCredentials(currentCredentials, callback) {
-    const CONTEXT = this;
-    async function finalize(cred) {
-      if (callback) await callback(cred);
-      return Promise.resolve(cred).then(async res => {
-        CONTEXT.removeIsTokenStartRefresh();
-        return res;
-      });
+  }, {
+    key: "setIsTokenStartRefresh",
+    value: function setIsTokenStartRefresh() {
+      localStorage.setItem(this.REFRESH_TOKEN_FLAG, true);
     }
-    if (!(currentCredentials !== null && currentCredentials !== void 0 && currentCredentials.token) || !(currentCredentials !== null && currentCredentials !== void 0 && currentCredentials.refreshToken)) return finalize(CONTEXT.DEFAULT_CREDENTIALS);
-
-    //! ВНИМАНИЕ! Данный механизм рефреша принят на проекте finturfreactfrontend (админка)
-    //! На кабинете он ТОЧНО НЕ ТАКОЙ
-    async function refreshCredentialsByDefault() {
-      const {
-        token,
-        refreshToken
-      } = currentCredentials;
-      const headers = new Headers();
-      headers.append(...Object.entries(CONTEXT.getHeadersForAuthorize(token)));
-      const body = new FormData();
-      body.append('grant_type', 'refresh_token');
-      body.append('refresh_token', refreshToken);
-      body.append('client_id', 'oauth');
-      body.append('client_secret', 'secret');
-      body.append('access_type', 'offline');
-      return fetch("".concat(CONTEXT.REFRESH_TOKEN_PATH), {
-        mode: 'cors',
-        method: 'POST',
-        headers,
-        body,
-        redirect: 'follow'
-      });
+  }, {
+    key: "removeIsTokenStartRefresh",
+    value: function removeIsTokenStartRefresh() {
+      localStorage.removeItem(this.REFRESH_TOKEN_FLAG);
     }
+  }, {
+    key: "getCredentials",
+    value: function () {
+      var _getCredentials = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(isCatchCallbackProcess, callback) {
+        var credentials, token, decoded, currentTime;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return this.getCredentialsByOuter();
 
-    //? Передавайте собственный refreshCredentials при получении экземляра RESTAPI, если не уверены,
-    //? что механизм рефреша токенов ИМЕННО ТАКОЙ как в ф-и refreshCredentialsByDefault!
-    //! currentCredentials передаются в формате класса! ({ token, refreshToken, expires })
-    const newCredentials = typeof CONTEXT.refreshCredentialsByOuter === 'function' ? await CONTEXT.refreshCredentialsByOuter(currentCredentials) : await refreshCredentialsByDefault();
-    return finalize(newCredentials);
-  }
-  async waitRefresh(isNeedRefresh) {
-    return new Promise(resolve => {
-      if (!this.getIsTokenStartRefresh()) {
-        if (isNeedRefresh) this.setIsTokenStartRefresh();
-        resolve();
-      } else {
-        const intervalId = setInterval(() => {
-          if (!this.getIsTokenStartRefresh()) {
-            clearInterval(intervalId);
-            resolve();
+              case 2:
+                credentials = _context.sent;
+
+                if (!(typeof this.importCredentials === 'function')) {
+                  _context.next = 7;
+                  break;
+                }
+
+                _context.next = 6;
+                return this.importCredentials(credentials);
+
+              case 6:
+                credentials = _context.sent;
+
+              case 7:
+                if (!(0, _utils.getIsOnlyAnObject)(credentials)) credentials = {};
+                token = credentials.token || null;
+
+                if (token && !isCatchCallbackProcess) {
+                  try {
+                    decoded = jwt.decode(token);
+                  } catch (_unused) {
+                    decoded = null;
+                  }
+
+                  currentTime = Date.now() / 1000;
+                  if (decoded !== null && +decoded.exp < currentTime) credentials = _objectSpread(_objectSpread({}, credentials), {}, {
+                    isNeedRefresh: true
+                  });
+                }
+
+                if (!callback) {
+                  _context.next = 13;
+                  break;
+                }
+
+                _context.next = 13;
+                return callback(_objectSpread(_objectSpread({}, credentials), {}, {
+                  isCatchCallbackProcess: isCatchCallbackProcess
+                }));
+
+              case 13:
+                return _context.abrupt("return", _objectSpread(_objectSpread({}, credentials), {}, {
+                  isCatchCallbackProcess: isCatchCallbackProcess
+                }));
+
+              case 14:
+              case "end":
+                return _context.stop();
+            }
           }
-        }, this.INTERVAL_FOR_CHECKING_TOKEN_UPDATE);
+        }, _callee, this);
+      }));
+
+      function getCredentials(_x, _x2) {
+        return _getCredentials.apply(this, arguments);
       }
-    });
-  }
-  async processCredentials(cred) {
-    if (!cred.isNeedRefresh && !cred.isCatchCallbackProcess) return cred;
-    const CONTEXT = this;
-    return CONTEXT.refreshCredentials(cred, response => CONTEXT.saveCredentials(response)).then(() => {
-      return new Promise(resolve => {
-        setTimeout(async () => {
-          var _CONTEXT$callbackAfte;
-          const newCredentials = await CONTEXT.getCredentials();
-          if (!(newCredentials !== null && newCredentials !== void 0 && newCredentials.token)) await (CONTEXT === null || CONTEXT === void 0 || (_CONTEXT$callbackAfte = CONTEXT.callbackAfterRejectRefresh) === null || _CONTEXT$callbackAfte === void 0 ? void 0 : _CONTEXT$callbackAfte.call(CONTEXT));
-          resolve(newCredentials);
-        }, 0);
-      });
-    });
-  }
-}
-var _default = exports.default = CredentialsProcessing;
+
+      return getCredentials;
+    }()
+  }, {
+    key: "refreshCredentials",
+    value: function () {
+      var _refreshCredentials = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(currentCredentials, callback) {
+        var CONTEXT, finalize, _finalize, refreshCredentialsByDefault, _refreshCredentialsByDefault, newCredentials;
+
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                _refreshCredentialsByDefault = function _refreshCredentialsBy2() {
+                  _refreshCredentialsByDefault = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
+                    var token, refreshToken, headers, body;
+                    return _regenerator.default.wrap(function _callee4$(_context4) {
+                      while (1) {
+                        switch (_context4.prev = _context4.next) {
+                          case 0:
+                            token = currentCredentials.token, refreshToken = currentCredentials.refreshToken;
+                            headers = new Headers();
+                            headers.append.apply(headers, (0, _toConsumableArray2.default)(Object.entries(CONTEXT.getHeadersForAuthorize(token))));
+                            body = new FormData();
+                            body.append('grant_type', 'refresh_token');
+                            body.append('refresh_token', refreshToken);
+                            body.append('client_id', 'oauth');
+                            body.append('client_secret', 'secret');
+                            body.append('access_type', 'offline');
+                            return _context4.abrupt("return", fetch("".concat(CONTEXT.REFRESH_TOKEN_PATH), {
+                              mode: 'cors',
+                              method: 'POST',
+                              headers: headers,
+                              body: body,
+                              redirect: 'follow'
+                            }));
+
+                          case 10:
+                          case "end":
+                            return _context4.stop();
+                        }
+                      }
+                    }, _callee4);
+                  }));
+                  return _refreshCredentialsByDefault.apply(this, arguments);
+                };
+
+                refreshCredentialsByDefault = function _refreshCredentialsBy() {
+                  return _refreshCredentialsByDefault.apply(this, arguments);
+                };
+
+                _finalize = function _finalize3() {
+                  _finalize = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(cred) {
+                    return _regenerator.default.wrap(function _callee3$(_context3) {
+                      while (1) {
+                        switch (_context3.prev = _context3.next) {
+                          case 0:
+                            if (!callback) {
+                              _context3.next = 3;
+                              break;
+                            }
+
+                            _context3.next = 3;
+                            return callback(cred);
+
+                          case 3:
+                            return _context3.abrupt("return", Promise.resolve(cred).then( /*#__PURE__*/function () {
+                              var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(res) {
+                                return _regenerator.default.wrap(function _callee2$(_context2) {
+                                  while (1) {
+                                    switch (_context2.prev = _context2.next) {
+                                      case 0:
+                                        CONTEXT.removeIsTokenStartRefresh();
+                                        return _context2.abrupt("return", res);
+
+                                      case 2:
+                                      case "end":
+                                        return _context2.stop();
+                                    }
+                                  }
+                                }, _callee2);
+                              }));
+
+                              return function (_x6) {
+                                return _ref2.apply(this, arguments);
+                              };
+                            }()));
+
+                          case 4:
+                          case "end":
+                            return _context3.stop();
+                        }
+                      }
+                    }, _callee3);
+                  }));
+                  return _finalize.apply(this, arguments);
+                };
+
+                finalize = function _finalize2(_x5) {
+                  return _finalize.apply(this, arguments);
+                };
+
+                CONTEXT = this;
+
+                if (!(!(currentCredentials !== null && currentCredentials !== void 0 && currentCredentials.token) || !(currentCredentials !== null && currentCredentials !== void 0 && currentCredentials.refreshToken))) {
+                  _context5.next = 7;
+                  break;
+                }
+
+                return _context5.abrupt("return", finalize(CONTEXT.DEFAULT_CREDENTIALS));
+
+              case 7:
+                if (!(typeof CONTEXT.refreshCredentialsByOuter === 'function')) {
+                  _context5.next = 13;
+                  break;
+                }
+
+                _context5.next = 10;
+                return CONTEXT.refreshCredentialsByOuter(currentCredentials);
+
+              case 10:
+                _context5.t0 = _context5.sent;
+                _context5.next = 16;
+                break;
+
+              case 13:
+                _context5.next = 15;
+                return refreshCredentialsByDefault();
+
+              case 15:
+                _context5.t0 = _context5.sent;
+
+              case 16:
+                newCredentials = _context5.t0;
+                return _context5.abrupt("return", finalize(newCredentials));
+
+              case 18:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+
+      function refreshCredentials(_x3, _x4) {
+        return _refreshCredentials.apply(this, arguments);
+      }
+
+      return refreshCredentials;
+    }()
+  }, {
+    key: "waitRefresh",
+    value: function () {
+      var _waitRefresh = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(isNeedRefresh) {
+        var _this = this;
+
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                return _context6.abrupt("return", new Promise(function (resolve) {
+                  if (!_this.getIsTokenStartRefresh()) {
+                    if (isNeedRefresh) _this.setIsTokenStartRefresh();
+                    resolve();
+                  } else {
+                    var intervalId = setInterval(function () {
+                      if (!_this.getIsTokenStartRefresh()) {
+                        clearInterval(intervalId);
+                        resolve();
+                      }
+                    }, _this.INTERVAL_FOR_CHECKING_TOKEN_UPDATE);
+                  }
+                }));
+
+              case 1:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6);
+      }));
+
+      function waitRefresh(_x7) {
+        return _waitRefresh.apply(this, arguments);
+      }
+
+      return waitRefresh;
+    }()
+  }, {
+    key: "processCredentials",
+    value: function () {
+      var _processCredentials = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8(cred) {
+        var CONTEXT;
+        return _regenerator.default.wrap(function _callee8$(_context8) {
+          while (1) {
+            switch (_context8.prev = _context8.next) {
+              case 0:
+                if (!(!cred.isNeedRefresh && !cred.isCatchCallbackProcess)) {
+                  _context8.next = 2;
+                  break;
+                }
+
+                return _context8.abrupt("return", cred);
+
+              case 2:
+                CONTEXT = this;
+                return _context8.abrupt("return", CONTEXT.refreshCredentials(cred, function (response) {
+                  return CONTEXT.saveCredentials(response);
+                }).then(function () {
+                  return new Promise(function (resolve) {
+                    setTimeout( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7() {
+                      var _CONTEXT$callbackAfte;
+
+                      var newCredentials;
+                      return _regenerator.default.wrap(function _callee7$(_context7) {
+                        while (1) {
+                          switch (_context7.prev = _context7.next) {
+                            case 0:
+                              _context7.next = 2;
+                              return CONTEXT.getCredentials();
+
+                            case 2:
+                              newCredentials = _context7.sent;
+
+                              if (newCredentials !== null && newCredentials !== void 0 && newCredentials.token) {
+                                _context7.next = 6;
+                                break;
+                              }
+
+                              _context7.next = 6;
+                              return CONTEXT === null || CONTEXT === void 0 ? void 0 : (_CONTEXT$callbackAfte = CONTEXT.callbackAfterRejectRefresh) === null || _CONTEXT$callbackAfte === void 0 ? void 0 : _CONTEXT$callbackAfte.call(CONTEXT);
+
+                            case 6:
+                              resolve(newCredentials);
+
+                            case 7:
+                            case "end":
+                              return _context7.stop();
+                          }
+                        }
+                      }, _callee7);
+                    })), 0);
+                  });
+                }));
+
+              case 4:
+              case "end":
+                return _context8.stop();
+            }
+          }
+        }, _callee8, this);
+      }));
+
+      function processCredentials(_x8) {
+        return _processCredentials.apply(this, arguments);
+      }
+
+      return processCredentials;
+    }()
+  }]);
+  return CredentialsProcessing;
+}();
+
+var _default = CredentialsProcessing;
+exports.default = _default;