@jetbrains/ring-ui 4.2.2 → 4.2.5

package/dist/auth/storage.js

@@ -1,283 +0,0 @@
-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 '../_helpers/_rollupPluginBabelHelpers.js';
-import 'react';
-import '../global/react-render-adapter.js';
-import 'react-dom';
-import '../global/get-uid.js';
-import '../alert/alert.js';
-import 'classnames';
-import 'prop-types';
-import '@jetbrains/icons/exception';
-import '@jetbrains/icons/checkmark';
-import '@jetbrains/icons/warning';
-import '@jetbrains/icons/close';
-import '../icon/icon.js';
-import 'util-deprecate';
-import '../icon/icon__constants.js';
-import '../_helpers/icon.js';
-import '../icon/icon__svg.js';
-import 'core-js/modules/es.string.replace.js';
-import '../global/memoize.js';
-import '../loader-inline/loader-inline.js';
-import '../global/theme.js';
-import '../global/data-tests.js';
-import '../_helpers/inject-styles.js';
-import '../global/conic-gradient.js';
-import 'conic-gradient';
-import '../global/supports-css.js';
-import '../global/inject-styles.js';
-import '../global/radial-gradient-mask.js';
-import '../global/dom.js';
-import '../alert/container.js';
-import '../storage/storage__fallback.js';
-import 'deep-equal';
-
-/**
- * @typedef {Object} StoredToken
- * @property {string} accessToken
- * @property {string[]} scopes
- * @property {number} expires
- */
-
-/**
- * @typedef {Object} StoredState
- * @property {Date} created
- * @property {string} restoreLocation
- * @property {string[]} scopes
- */
-
-const DEFAULT_STATE_QUOTA = 102400; // 100 kb ~~ 200 tabs with a large list of scopes
-// eslint-disable-next-line no-magic-numbers
-
-const DEFAULT_STATE_TTL = 1000 * 60 * 60 * 24; // nobody will need auth state after a day
-
-const UPDATE_USER_TIMEOUT = 1000;
-class AuthStorage {
-  /**
-   * Custom storage for Auth
-   * @param {{stateKeyPrefix: string, tokenKey: string, onTokenRemove: Function}} config
-   */
-  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;
-    const StorageConstructor = config.storage || ActualStorage;
-    this.stateQuota = Math.min(config.stateQuota || DEFAULT_STATE_QUOTA, StorageConstructor.QUOTA || Infinity);
-    this._stateStorage = new StorageConstructor({
-      cookieName: 'ring-state'
-    });
-    this._tokenStorage = new StorageConstructor({
-      cookieName: 'ring-token'
-    });
-    this._messagesStorage = new StorageConstructor({
-      cookieName: 'ring-message'
-    });
-    this._currentUserStorage = new StorageConstructor({
-      cookieName: 'ring-user'
-    });
-  }
-  /**
-   * Add token change listener
-   * @param {function(string)} fn Token change listener
-   * @return {function()} remove listener 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
-   */
-
-
-  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;
-      }
-    }
-
-    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, state) => {
-      // Remove requested state
-      if (key === this.stateKeyPrefix + removeStateId) {
-        return this._stateStorage.remove(key);
-      }
-
-      if (key.indexOf(this.stateKeyPrefix) === 0) {
-        // Clean old states
-        if (state.created + this.stateTTL < now) {
-          return this._stateStorage.remove(key);
-        } // Data to clean up due quota
-
-
-        return {
-          key,
-          created: state.created,
-          size: JSON.stringify(state).length
-        };
-      }
-
-      return undefined;
-    });
-    const currentStates = removalResult.filter(state => state);
-    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);
-    }
-
-    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;
-    }
-  }
-  /**
-   * @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 };

package/dist/auth/token-validator.js

@@ -1,178 +0,0 @@
-import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
-import ExtendableError from 'es6-error';
-import { CODE } from '../http/http.js';
-import 'core-js/modules/web.dom-collections.iterator.js';
-import '../global/url.js';
-import 'core-js/modules/es.string.replace.js';
-
-class TokenValidator {
-  constructor(config, getUser, storage) {
-    this._getUser = getUser;
-    this._config = config;
-    this._storage = storage;
-  }
-  /**
-   * Returns epoch - seconds since 1970.
-   * Used for calculation of expire times.
-   * @return {number} epoch, seconds since 1970
-   * @private
-   */
-
-
-  static _epoch() {
-    const milliseconds = 1000.0;
-    return Math.round(Date.now() / milliseconds);
-  }
-  /**
-   * @const {number}
-   */
-  // eslint-disable-next-line no-magic-numbers
-
-
-  /**
-   * Check token validity against all conditions.
-   * @returns {Promise.<string>}
-   */
-  validateTokenLocally() {
-    return this._getValidatedToken([TokenValidator._validateExistence, TokenValidator._validateExpiration, this._validateScopes.bind(this)]);
-  }
-  /**
-   * Check token validity against all conditions.
-   * @returns {Promise.<string>}
-   */
-
-
-  validateToken() {
-    return this._getValidatedToken([TokenValidator._validateExistence, TokenValidator._validateExpiration, this._validateScopes.bind(this), this._validateAgainstUser.bind(this)]);
-  }
-  /**
-   * Check if there is a token
-   * @param {StoredToken} storedToken
-   * @return {Promise.<StoredToken>}
-   * @private
-   */
-
-
-  static _validateExistence(storedToken) {
-    if (!storedToken || !storedToken.accessToken) {
-      throw new TokenValidator.TokenValidationError('Token not found');
-    }
-  }
-  /**
-   * Check expiration
-   * @param {StoredToken} storedToken
-   * @return {Promise.<StoredToken>}
-   * @private
-   */
-
-
-  static _validateExpiration(_ref) {
-    let {
-      expires,
-      lifeTime
-    } = _ref;
-    const REFRESH_BEFORE_RATIO = 6;
-    const refreshBefore = lifeTime ? Math.ceil(lifeTime / REFRESH_BEFORE_RATIO) : TokenValidator.DEFAULT_REFRESH_BEFORE;
-
-    if (expires && expires < TokenValidator._epoch() + refreshBefore) {
-      throw new TokenValidator.TokenValidationError('Token expired');
-    }
-  }
-  /**
-   * Check scopes
-   * @param {StoredToken} storedToken
-   * @return {Promise.<StoredToken>}
-   * @private
-   */
-
-
-  _validateScopes(storedToken) {
-    const {
-      scope,
-      optionalScopes
-    } = this._config;
-    const requiredScopes = optionalScopes ? scope.filter(scopeId => !optionalScopes.includes(scopeId)) : scope;
-    const hasAllScopes = requiredScopes.every(scopeId => storedToken.scopes.includes(scopeId));
-
-    if (!hasAllScopes) {
-      throw new TokenValidator.TokenValidationError('Token doesn\'t match required scopes');
-    }
-  }
-  /**
-   * Check by error code if token should be refreshed
-   * @param {string} error
-   * @return {boolean}
-   */
-
-
-  static shouldRefreshToken(error) {
-    return error === 'invalid_grant' || error === 'invalid_request' || error === 'invalid_token';
-  }
-  /**
-   * Check scopes
-   * @param {StoredToken} storedToken
-   * @return {Promise.<StoredToken>}
-   * @private
-   */
-
-
-  async _validateAgainstUser(storedToken) {
-    try {
-      return await this._getUser(storedToken.accessToken);
-    } catch (errorResponse) {
-      let response = {};
-
-      try {
-        response = await errorResponse.response.json();
-      } catch (e) {// Skip JSON parsing errors
-      }
-
-      if (errorResponse.status === CODE.UNAUTHORIZED || TokenValidator.shouldRefreshToken(response.error)) {
-        // Token expired
-        throw new TokenValidator.TokenValidationError(response.error || errorResponse.message);
-      } // Request unexpectedly failed
-
-
-      throw errorResponse;
-    }
-  }
-  /**
-   * Token Validator function
-   * @typedef {(function(StoredToken): Promise<StoredToken>)} TokenValidator
-   */
-
-  /**
-   * Gets stored token and applies provided validators
-   * @param {TokenValidator[]} validators An array of validation
-   * functions to check the stored token against.
-   * @return {Promise.<string>} promise that is resolved to access token if the stored token is valid. If it is
-   * invalid then the promise is rejected. If invalid token should be re-requested then rejection object will
-   * have {authRedirect: true}.
-   * @private
-   */
-
-
-  async _getValidatedToken(validators) {
-    const storedToken = await this._storage.getToken();
-
-    for (let i = 0; i < validators.length; i++) {
-      await validators[i](storedToken);
-    }
-
-    return storedToken.accessToken;
-  }
-
-}
-
-_defineProperty(TokenValidator, "DEFAULT_REFRESH_BEFORE", 10 * 60);
-
-_defineProperty(TokenValidator, "TokenValidationError", class TokenValidationError extends ExtendableError {
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-    this.authRedirect = true;
-  }
-
-});
-
-export { TokenValidator as default };

package/dist/auth/window-flow.js

@@ -1,134 +0,0 @@
-import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
-import AuthResponseParser from './response-parser.js';
-import 'core-js/modules/es.string.replace.js';
-import 'es6-error';
-import '../global/url.js';
-
-const NAVBAR_HEIGHT = 50;
-const CLOSED_CHECK_INTERVAL = 200;
-class WindowFlow {
-  constructor(requestBuilder, storage) {
-    _defineProperty(this, "_timeoutId", null);
-
-    _defineProperty(this, "checkIsClosed", () => {
-      if (this._loginWindow.closed) {
-        this.stop();
-        return;
-      }
-
-      this._timeoutId = setTimeout(this.checkIsClosed, CLOSED_CHECK_INTERVAL);
-    });
-
-    _defineProperty(this, "_reset", () => {
-      this._promise = null;
-      this._loginWindow = null;
-      clearTimeout(this._timeoutId);
-    });
-
-    this._requestBuilder = requestBuilder;
-    this._storage = storage;
-
-    this._reset();
-  }
-  /**
-   * Opens window with the given URL
-   * @param {string} url
-   * @private
-   */
-
-
-  _openWindow(url) {
-    const height = 700;
-    const width = 750;
-    const screenHalves = 2;
-    const top = (window.screen.height - height - NAVBAR_HEIGHT) / screenHalves;
-    const left = (window.screen.width - width) / screenHalves;
-    return window.open(url, 'HubLoginWindow', "height=".concat(height, ", width=").concat(width, ", left=").concat(left, ", top=").concat(top));
-  }
-  /**
-   * Initiates authorization in window
-   */
-
-
-  async _load() {
-    const authRequest = await this._requestBuilder.prepareAuthRequest( // eslint-disable-next-line camelcase
-    {
-      request_credentials: 'required',
-      auth_mode: 'bypass_to_login'
-    }, {
-      nonRedirect: true
-    });
-    return new Promise((resolve, reject) => {
-      this.reject = reject;
-      let cleanRun;
-
-      const cleanUp = () => {
-        if (cleanRun) {
-          return;
-        }
-
-        cleanRun = true;
-        /* eslint-disable no-use-before-define */
-
-        removeStateListener();
-        removeTokenListener();
-        /* eslint-enable no-use-before-define */
-
-        this._loginWindow.close();
-
-        clearTimeout(this._timeoutId);
-      };
-
-      const removeTokenListener = this._storage.onTokenChange(token => {
-        if (token) {
-          cleanUp();
-          resolve(token.accessToken);
-        }
-      });
-
-      const removeStateListener = this._storage.onStateChange(authRequest.stateId, state => {
-        if (state && state.error) {
-          cleanUp();
-          reject(new AuthResponseParser.AuthError(state));
-        }
-      });
-
-      if (this._loginWindow === null || this._loginWindow.closed === true) {
-        this._loginWindow = this._openWindow(authRequest.url);
-      } else {
-        this._loginWindow.location = authRequest.url;
-      }
-
-      this.checkIsClosed();
-    });
-  }
-
-  stop() {
-    if (this._loginWindow !== null) {
-      this._loginWindow.close();
-    }
-
-    if (this.reject) {
-      this.reject('Authorization window closed');
-    }
-
-    this._reset();
-  }
-
-  authorize() {
-    if (this._promise !== null && this._loginWindow !== null && this._loginWindow.closed !== true) {
-      this._loginWindow.focus();
-
-      return this._promise;
-    }
-
-    this._promise = this._load();
-
-    this._promise.then(this._reset, this._reset);
-
-    return this._promise;
-  }
-
-}
-
-export { WindowFlow as default };