@jetbrains/ring-ui-built 6.0.31 → 6.0.32

package/components/auth/storage.js

@@ -1,23 +1,11 @@
-import { b as _createClass, f as _classCallCheck, _ as _defineProperty, h as _asyncToGenerator, i as _regeneratorRuntime } from '../_helpers/_rollupPluginBabelHelpers.js';
-import 'core-js/modules/es.array.filter.js';
-import 'core-js/modules/es.array.index-of.js';
-import 'core-js/modules/es.array.iterator.js';
-import 'core-js/modules/es.array.map.js';
-import 'core-js/modules/es.array.reduce.js';
-import 'core-js/modules/es.array.sort.js';
-import 'core-js/modules/es.object.to-string.js';
-import 'core-js/modules/es.promise.js';
-import 'core-js/modules/web.dom-collections.iterator.js';
 import ActualStorage from '../storage/storage.js';
 import '../storage/storage__local.js';
 import '../alert-service/alert-service.js';
-import 'core-js/modules/es.array.concat.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
 import 'react';
 import 'react-dom/client';
 import '../global/get-uid.js';
-import 'core-js/modules/es.regexp.to-string.js';
 import '../alert/alert.js';
-import 'core-js/modules/es.object.values.js';
 import 'classnames';
 import 'prop-types';
 import '@jetbrains/icons/exception';
@@ -28,20 +16,10 @@ import '../icon/icon.js';
 import 'util-deprecate';
 import '../icon/icon__constants.js';
 import '../_helpers/icon__svg.js';
-import 'core-js/modules/es.regexp.exec.js';
-import 'core-js/modules/es.string.replace.js';
-import 'core-js/modules/es.string.starts-with.js';
 import '../global/memoize.js';
-import 'core-js/modules/es.map.js';
-import 'core-js/modules/es.weak-map.js';
 import '../loader-inline/loader-inline.js';
 import '../global/data-tests.js';
-import 'core-js/modules/es.object.entries.js';
 import '../global/dom.js';
-import 'core-js/modules/es.object.assign.js';
-import 'core-js/modules/es.set.js';
-import 'core-js/modules/es.string.split.js';
-import 'core-js/modules/web.dom-collections.for-each.js';
 import '../button/button.js';
 import '@jetbrains/icons/chevron-10px';
 import '../link/clickableLink.js';
@@ -54,12 +32,6 @@ import '../popup/popup.js';
 import '../global/schedule-raf.js';
 import '../shortcuts/shortcuts.js';
 import '../shortcuts/core.js';
-import 'core-js/modules/es.array.find-index.js';
-import 'core-js/modules/es.array.includes.js';
-import 'core-js/modules/es.array.slice.js';
-import 'core-js/modules/es.array.splice.js';
-import 'core-js/modules/es.string.includes.js';
-import 'core-js/modules/es.string.match.js';
 import 'combokeys';
 import '../global/sniffer.js';
 import 'sniffr';
@@ -68,7 +40,6 @@ import '../popup/position.js';
 import '../popup/popup.consts.js';
 import '../alert/container.js';
 import '../storage/storage__fallback.js';
-import 'core-js/modules/es.reflect.delete-property.js';
 import 'deep-equal';
 
 /**
@@ -83,35 +54,34 @@ import 'deep-equal';
  * @property {string} restoreLocation
  * @property {string[]} scopes
  */
-var DEFAULT_STATE_QUOTA = 102400; // 100 kb ~~ 200 tabs with a large list of scopes
+const DEFAULT_STATE_QUOTA = 102400; // 100 kb ~~ 200 tabs with a large list of scopes
 // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-var DEFAULT_STATE_TTL = 1000 * 60 * 60 * 24; // nobody will need auth state after a day
-var UPDATE_USER_TIMEOUT = 1000;
-var AuthStorage = /*#__PURE__*/function () {
+const DEFAULT_STATE_TTL = 1000 * 60 * 60 * 24; // nobody will need auth state after a day
+const UPDATE_USER_TIMEOUT = 1000;
+class AuthStorage {
+  messagePrefix;
+  stateKeyPrefix;
+  tokenKey;
+  userKey;
+  stateTTL;
+  stateQuota;
+  _lastMessage;
+  _stateStorage;
+  _tokenStorage;
+  _messagesStorage;
+  _currentUserStorage;
   /**
    * Custom storage for Auth
    * @param {{stateKeyPrefix: string, tokenKey: string, onTokenRemove: Function}} config
    */
-  function AuthStorage(config) {
-    _classCallCheck(this, AuthStorage);
-    _defineProperty(this, "messagePrefix", void 0);
-    _defineProperty(this, "stateKeyPrefix", void 0);
-    _defineProperty(this, "tokenKey", void 0);
-    _defineProperty(this, "userKey", void 0);
-    _defineProperty(this, "stateTTL", void 0);
-    _defineProperty(this, "stateQuota", void 0);
-    _defineProperty(this, "_lastMessage", void 0);
-    _defineProperty(this, "_stateStorage", void 0);
-    _defineProperty(this, "_tokenStorage", void 0);
-    _defineProperty(this, "_messagesStorage", void 0);
-    _defineProperty(this, "_currentUserStorage", void 0);
+  constructor(config) {
     this.messagePrefix = config.messagePrefix || '';
     this.stateKeyPrefix = config.stateKeyPrefix || '';
     this.tokenKey = config.tokenKey || '';
     this.userKey = config.userKey || 'user-key';
     this.stateTTL = config.stateTTL || DEFAULT_STATE_TTL;
     this._lastMessage = null;
-    var StorageConstructor = config.storage || ActualStorage;
+    const StorageConstructor = config.storage || ActualStorage;
     this.stateQuota = Math.min(config.stateQuota || DEFAULT_STATE_QUOTA, StorageConstructor.QUOTA || Infinity);
     this._stateStorage = new StorageConstructor({
       cookieName: 'ring-state'
@@ -131,298 +101,165 @@ var AuthStorage = /*#__PURE__*/function () {
    * @param {function(string)} fn Token change listener
    * @return {function()} remove listener function
    */
-  return _createClass(AuthStorage, [{
-    key: "onTokenChange",
-    value: function onTokenChange(fn) {
-      return this._tokenStorage.on(this.tokenKey, fn);
-    }
-    /**
-     * Add state change listener
-     * @param {string} stateKey State key
-     * @param {function(string)} fn State change listener
-     * @return {function()} remove listener function
-     */
-  }, {
-    key: "onStateChange",
-    value: function onStateChange(stateKey, fn) {
-      return this._stateStorage.on(this.stateKeyPrefix + stateKey, fn);
-    }
-    /**
-     * Add state change listener
-     * @param {string} key State key
-     * @param {function(string)} fn State change listener
-     * @return {function()} remove listener function
-     */
-  }, {
-    key: "onMessage",
-    value: function onMessage(key, fn) {
-      return this._messagesStorage.on(this.messagePrefix + key, function (message) {
-        return fn(message);
-      });
-    }
-  }, {
-    key: "sendMessage",
-    value: function sendMessage(key) {
-      var message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-      this._lastMessage = message;
-      this._messagesStorage.set(this.messagePrefix + key, message);
+  onTokenChange(fn) {
+    return this._tokenStorage.on(this.tokenKey, fn);
+  }
+  /**
+   * Add state change listener
+   * @param {string} stateKey State key
+   * @param {function(string)} fn State change listener
+   * @return {function()} remove listener function
+   */
+  onStateChange(stateKey, fn) {
+    return this._stateStorage.on(this.stateKeyPrefix + stateKey, fn);
+  }
+  /**
+   * Add state change listener
+   * @param {string} key State key
+   * @param {function(string)} fn State change listener
+   * @return {function()} remove listener function
+   */
+  onMessage(key, fn) {
+    return this._messagesStorage.on(this.messagePrefix + key, message => fn(message));
+  }
+  sendMessage(key) {
+    let message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    this._lastMessage = message;
+    this._messagesStorage.set(this.messagePrefix + key, message);
+  }
+  /**
+   * Save authentication request state.
+   *
+   * @param {string} id Unique state identifier
+   * @param {StoredState} state State to store
+   * @param {boolean=} dontCleanAndRetryOnFail If falsy then remove all stored states and try again to save state
+   */
+  async saveState(id, state, dontCleanAndRetryOnFail) {
+    state.created = Date.now();
+    try {
+      await this._stateStorage.set(this.stateKeyPrefix + id, state);
+    } catch (e) {
+      if (!dontCleanAndRetryOnFail) {
+        await this.cleanStates();
+        return this.saveState(id, state, true);
+      } else {
+        throw e;
+      }
     }
-    /**
-     * Save authentication request state.
-     *
-     * @param {string} id Unique state identifier
-     * @param {StoredState} state State to store
-     * @param {boolean=} dontCleanAndRetryOnFail If falsy then remove all stored states and try again to save state
-     */
-  }, {
-    key: "saveState",
-    value: (function () {
-      var _saveState = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(id, state, dontCleanAndRetryOnFail) {
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              state.created = Date.now();
-              _context.prev = 1;
-              _context.next = 4;
-              return this._stateStorage.set(this.stateKeyPrefix + id, state);
-            case 4:
-              _context.next = 15;
-              break;
-            case 6:
-              _context.prev = 6;
-              _context.t0 = _context["catch"](1);
-              if (dontCleanAndRetryOnFail) {
-                _context.next = 14;
-                break;
-              }
-              _context.next = 11;
-              return this.cleanStates();
-            case 11:
-              return _context.abrupt("return", this.saveState(id, state, true));
-            case 14:
-              throw _context.t0;
-            case 15:
-              return _context.abrupt("return", undefined);
-            case 16:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this, [[1, 6]]);
-      }));
-      function saveState(_x, _x2, _x3) {
-        return _saveState.apply(this, arguments);
+    return undefined;
+  }
+  /**
+   * Remove all stored states
+   *
+   * @return {Promise} promise that is resolved when OLD states [and some selected] are removed
+   */
+  async cleanStates(removeStateId) {
+    const now = Date.now();
+    const removalResult = await this._stateStorage.each((key, value) => {
+      if (value == null) {
+        return undefined;
       }
-      return saveState;
-    }()
-    /**
-     * Remove all stored states
-     *
-     * @return {Promise} promise that is resolved when OLD states [and some selected] are removed
-     */
-    )
-  }, {
-    key: "cleanStates",
-    value: (function () {
-      var _cleanStates = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(removeStateId) {
-        var _this = this;
-        var now, removalResult, currentStates, stateStorageSize, removalPromises;
-        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              now = Date.now();
-              _context2.next = 3;
-              return this._stateStorage.each(function (key, value) {
-                if (value == null) {
-                  return undefined;
-                }
-                // Remove requested state
-                if (key === _this.stateKeyPrefix + removeStateId) {
-                  return _this._stateStorage.remove(key);
-                }
-                if (key.indexOf(_this.stateKeyPrefix) === 0) {
-                  var _state$created;
-                  // Clean old states
-                  var state = value;
-                  var created = (_state$created = state.created) !== null && _state$created !== void 0 ? _state$created : Date.now();
-                  if (created + _this.stateTTL < now) {
-                    return _this._stateStorage.remove(key);
-                  }
-                  // Data to clean up due quota
-                  return {
-                    key,
-                    created,
-                    size: JSON.stringify(state).length
-                  };
-                }
-                return undefined;
-              });
-            case 3:
-              removalResult = _context2.sent;
-              currentStates = removalResult.filter(function (state) {
-                return state != null;
-              });
-              stateStorageSize = currentStates.reduce(function (overallSize, state) {
-                return state.size + overallSize;
-              }, 0);
-              if (!(stateStorageSize > this.stateQuota)) {
-                _context2.next = 10;
-                break;
-              }
-              currentStates.sort(function (a, b) {
-                return a.created - b.created;
-              });
-              removalPromises = currentStates.filter(function (state) {
-                if (stateStorageSize > _this.stateQuota) {
-                  stateStorageSize -= state.size;
-                  return true;
-                }
-                return false;
-              }).map(function (state) {
-                return _this._stateStorage.remove(state.key);
-              });
-              return _context2.abrupt("return", removalPromises.length && Promise.all(removalPromises));
-            case 10:
-              return _context2.abrupt("return", undefined);
-            case 11:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this);
-      }));
-      function cleanStates(_x4) {
-        return _cleanStates.apply(this, arguments);
+      // Remove requested state
+      if (key === this.stateKeyPrefix + removeStateId) {
+        return this._stateStorage.remove(key);
       }
-      return cleanStates;
-    }()
-    /**
-     * Get state by id and remove stored states from the storage.
-     *
-     * @param {string} id unique state identifier
-     * @return {Promise.<StoredState>}
-     */
-    )
-  }, {
-    key: "getState",
-    value: (function () {
-      var _getState = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(id) {
-        var result;
-        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              _context3.prev = 0;
-              _context3.next = 3;
-              return this._stateStorage.get(this.stateKeyPrefix + id);
-            case 3:
-              result = _context3.sent;
-              _context3.next = 6;
-              return this.cleanStates(id);
-            case 6:
-              return _context3.abrupt("return", result);
-            case 9:
-              _context3.prev = 9;
-              _context3.t0 = _context3["catch"](0);
-              _context3.next = 13;
-              return this.cleanStates(id);
-            case 13:
-              throw _context3.t0;
-            case 14:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this, [[0, 9]]);
-      }));
-      function getState(_x5) {
-        return _getState.apply(this, arguments);
+      if (key.indexOf(this.stateKeyPrefix) === 0) {
+        var _state$created;
+        // Clean old states
+        const state = value;
+        const created = (_state$created = state.created) !== null && _state$created !== void 0 ? _state$created : Date.now();
+        if (created + this.stateTTL < now) {
+          return this._stateStorage.remove(key);
+        }
+        // Data to clean up due quota
+        return {
+          key,
+          created,
+          size: JSON.stringify(state).length
+        };
       }
-      return getState;
-    }()
-    /**
-     * @param {StoredToken} token
-     * @return {Promise} promise that is resolved when the token is saved
-     */
-    )
-  }, {
-    key: "saveToken",
-    value: function saveToken(token) {
-      return this._tokenStorage.set(this.tokenKey, token);
-    }
-    /**
-     * @return {Promise.<StoredToken>} promise that is resolved to the stored token
-     */
-  }, {
-    key: "getToken",
-    value: function getToken() {
-      return this._tokenStorage.get(this.tokenKey);
-    }
-    /**
-     * Remove stored token if any.
-     * @return {Promise} promise that is resolved when the token is wiped.
-     */
-  }, {
-    key: "wipeToken",
-    value: function wipeToken() {
-      return this._tokenStorage.remove(this.tokenKey);
+      return undefined;
+    });
+    const currentStates = removalResult.filter(state => state != null);
+    let stateStorageSize = currentStates.reduce((overallSize, state) => state.size + overallSize, 0);
+    if (stateStorageSize > this.stateQuota) {
+      currentStates.sort((a, b) => a.created - b.created);
+      const removalPromises = currentStates.filter(state => {
+        if (stateStorageSize > this.stateQuota) {
+          stateStorageSize -= state.size;
+          return true;
+        }
+        return false;
+      }).map(state => this._stateStorage.remove(state.key));
+      return removalPromises.length && Promise.all(removalPromises);
     }
-    /**
-     * @param {function} loadUser user loader
-     * @return {Promise.<object>>} promise that is resolved to stored current user
-     */
-  }, {
-    key: "getCachedUser",
-    value: (function () {
-      var _getCachedUser = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(loadUser) {
-        var _this2 = this;
-        var user, loadAndCache;
-        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
-            case 0:
-              _context4.next = 2;
-              return this._currentUserStorage.get(this.userKey);
-            case 2:
-              user = _context4.sent;
-              loadAndCache = function loadAndCache() {
-                return loadUser().then(function (response) {
-                  _this2._currentUserStorage.set(_this2.userKey, response);
-                  return response;
-                });
-              };
-              if (!(user && user.id)) {
-                _context4.next = 9;
-                break;
-              }
-              setTimeout(loadAndCache, UPDATE_USER_TIMEOUT);
-              return _context4.abrupt("return", user);
-            case 9:
-              return _context4.abrupt("return", loadAndCache());
-            case 10:
-            case "end":
-              return _context4.stop();
-          }
-        }, _callee4, this);
-      }));
-      function getCachedUser(_x6) {
-        return _getCachedUser.apply(this, arguments);
-      }
-      return getCachedUser;
-    }()
-    /**
-     * Remove cached user if any
-     */
-    )
-  }, {
-    key: "wipeCachedCurrentUser",
-    value: function wipeCachedCurrentUser() {
-      return this._currentUserStorage.remove(this.userKey);
+    return undefined;
+  }
+  /**
+   * Get state by id and remove stored states from the storage.
+   *
+   * @param {string} id unique state identifier
+   * @return {Promise.<StoredState>}
+   */
+  async getState(id) {
+    try {
+      const result = await this._stateStorage.get(this.stateKeyPrefix + id);
+      await this.cleanStates(id);
+      return result;
+    } catch (e) {
+      await this.cleanStates(id);
+      throw e;
     }
-    /**
-     * Wipes cache if user has changed
-     */
-  }, {
-    key: "onUserChanged",
-    value: function onUserChanged() {
-      this.wipeCachedCurrentUser();
+  }
+  /**
+   * @param {StoredToken} token
+   * @return {Promise} promise that is resolved when the token is saved
+   */
+  saveToken(token) {
+    return this._tokenStorage.set(this.tokenKey, token);
+  }
+  /**
+   * @return {Promise.<StoredToken>} promise that is resolved to the stored token
+   */
+  getToken() {
+    return this._tokenStorage.get(this.tokenKey);
+  }
+  /**
+   * Remove stored token if any.
+   * @return {Promise} promise that is resolved when the token is wiped.
+   */
+  wipeToken() {
+    return this._tokenStorage.remove(this.tokenKey);
+  }
+  /**
+   * @param {function} loadUser user loader
+   * @return {Promise.<object>>} promise that is resolved to stored current user
+   */
+  async getCachedUser(loadUser) {
+    const user = await this._currentUserStorage.get(this.userKey);
+    const loadAndCache = () => loadUser().then(response => {
+      this._currentUserStorage.set(this.userKey, response);
+      return response;
+    });
+    if (user && user.id) {
+      setTimeout(loadAndCache, UPDATE_USER_TIMEOUT);
+      return user;
+    } else {
+      return loadAndCache();
     }
-  }]);
-}();
+  }
+  /**
+   * Remove cached user if any
+   */
+  wipeCachedCurrentUser() {
+    return this._currentUserStorage.remove(this.userKey);
+  }
+  /**
+   * Wipes cache if user has changed
+   */
+  onUserChanged() {
+    this.wipeCachedCurrentUser();
+  }
+}
 
 export { AuthStorage as default };