intelicoreact 1.3.21 → 1.3.22

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

@@ -1,461 +1,213 @@
 "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");
-
-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;
-
+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 || {};
     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; //? Если метод передан или если не передан, но включен флоу обновления токенов (тогда saveCredentials обязателен)
+    this.importCredentials = importCredentials;
 
+    //? Если метод передан или если не передан, но включен флоу обновления токенов (тогда 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(function (i) {
-        return typeof i === 'number';
-      })) {
+      if (!CODES_USING_THE_REFRESH_ATTEMPT.every(i => 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;
     }
   }
-
-  (0, _createClass2.default)(CredentialsProcessing, [{
-    key: "getIsTokenStartRefresh",
-    value: function getIsTokenStartRefresh() {
-      return localStorage.getItem(this.REFRESH_TOKEN_FLAG);
+  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
+      };
     }
-  }, {
-    key: "setIsTokenStartRefresh",
-    value: function setIsTokenStartRefresh() {
-      localStorage.setItem(this.REFRESH_TOKEN_FLAG, true);
+    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: "removeIsTokenStartRefresh",
-    value: function removeIsTokenStartRefresh() {
-      localStorage.removeItem(this.REFRESH_TOKEN_FLAG);
+    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: "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();
-
-              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();
-            }
-          }
-        }, _callee, this);
-      }));
-
-      function getCredentials(_x, _x2) {
-        return _getCredentials.apply(this, arguments);
-      }
-
-      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();
-            }
+    //? Передавайте собственный 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();
           }
-        }, _callee8, this);
-      }));
-
-      function processCredentials(_x8) {
-        return _processCredentials.apply(this, arguments);
+        }, this.INTERVAL_FOR_CHECKING_TOKEN_UPDATE);
       }
-
-      return processCredentials;
-    }()
-  }]);
-  return CredentialsProcessing;
-}();
-
-var _default = CredentialsProcessing;
-exports.default = _default;
+    });
+  }
+  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;