@jetbrains/ring-ui-built 7.0.0-beta.1 → 7.0.0-beta.3

package/components/auth/token-validator.js

@@ -1,41 +1,22 @@
-import { _ as _defineProperty, a as _inherits, b as _createClass, e as _classCallCheck, f as _callSuper, g as _asyncToGenerator, h as _regeneratorRuntime } from '../_helpers/_rollupPluginBabelHelpers.js';
-import 'core-js/modules/es.array.filter.js';
-import 'core-js/modules/es.array.includes.js';
-import 'core-js/modules/es.object.to-string.js';
-import 'core-js/modules/es.string.includes.js';
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
 import ExtendableError from 'es6-error';
 import { CODE } from '../http/http.js';
-import 'core-js/modules/es.array.concat.js';
-import 'core-js/modules/es.array.index-of.js';
-import 'core-js/modules/es.array.iterator.js';
-import 'core-js/modules/es.object.entries.js';
-import 'core-js/modules/es.promise.js';
-import 'core-js/modules/es.reflect.delete-property.js';
-import 'core-js/modules/es.weak-map.js';
-import 'core-js/modules/web.dom-collections.for-each.js';
 import 'core-js/modules/web.dom-collections.iterator.js';
 import '../global/url.js';
 import 'core-js/modules/es.regexp.exec.js';
-import 'core-js/modules/es.string.match.js';
 import 'core-js/modules/es.string.replace.js';
 
-var TokenValidationError = /*#__PURE__*/function (_ExtendableError) {
-  function TokenValidationError(message, cause) {
-    var _this;
-    _classCallCheck(this, TokenValidationError);
-    _this = _callSuper(this, TokenValidationError, [message]);
-    _defineProperty(_this, "cause", void 0);
-    _defineProperty(_this, "authRedirect", void 0);
-    _this.cause = cause;
-    _this.authRedirect = true;
-    return _this;
+class TokenValidationError extends ExtendableError {
+  constructor(message, cause) {
+    super(message);
+    _defineProperty(this, "cause", void 0);
+    _defineProperty(this, "authRedirect", void 0);
+    this.cause = cause;
+    this.authRedirect = true;
   }
-  _inherits(TokenValidationError, _ExtendableError);
-  return _createClass(TokenValidationError);
-}(ExtendableError);
-var TokenValidator = /*#__PURE__*/function () {
-  function TokenValidator(config, getUser, storage) {
-    _classCallCheck(this, TokenValidator);
+}
+class TokenValidator {
+  constructor(config, getUser, storage) {
     _defineProperty(this, "_getUser", void 0);
     _defineProperty(this, "_config", void 0);
     _defineProperty(this, "_storage", void 0);
@@ -49,211 +30,135 @@ var TokenValidator = /*#__PURE__*/function () {
    * @return {number} epoch, seconds since 1970
    * @private
    */
-  return _createClass(TokenValidator, [{
-    key: "validateTokenLocally",
-    value:
-    /**
-     * Check token validity against all conditions.
-     * @returns {Promise.<string>}
-     */
-    function validateTokenLocally() {
-      return this._getValidatedToken([TokenValidator._validateExistence, TokenValidator._validateExpiration, this._validateScopes.bind(this)]);
+  static _epoch() {
+    const milliseconds = 1000.0;
+    return Math.round(Date.now() / milliseconds);
+  }
+  /**
+   * @const {number}
+   */
+  // eslint-disable-next-line @typescript-eslint/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 token validity against all conditions.
-     * @returns {Promise.<string>}
-     */
-  }, {
-    key: "validateToken",
-    value: function validateToken() {
-      return this._getValidatedToken([TokenValidator._validateExistence, TokenValidator._validateExpiration, this._validateScopes.bind(this), this._validateAgainstUser.bind(this)]);
+  }
+  /**
+   * 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 if there is a token
-     * @param {StoredToken} storedToken
-     * @return {Promise.<StoredToken>}
-     * @private
-     */
-  }, {
-    key: "_validateScopes",
-    value:
-    /**
-     * Check scopes
-     * @param {StoredToken} storedToken
-     * @return {Promise.<StoredToken>}
-     * @private
-     */
-    function _validateScopes(storedToken) {
-      var _this$_config = this._config,
-        scope = _this$_config.scope,
-        optionalScopes = _this$_config.optionalScopes;
-      var requiredScopes = optionalScopes ? scope.filter(function (scopeId) {
-        return !optionalScopes.includes(scopeId);
-      }) : scope;
-      var hasAllScopes = requiredScopes.every(function (scopeId) {
-        var _storedToken$scopes;
-        return (_storedToken$scopes = storedToken.scopes) === null || _storedToken$scopes === void 0 ? void 0 : _storedToken$scopes.includes(scopeId);
-      });
-      if (!hasAllScopes) {
-        throw new TokenValidator.TokenValidationError('Token doesn\'t match required scopes');
-      }
+  }
+  /**
+   * 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 => {
+      var _storedToken$scopes;
+      return (_storedToken$scopes = storedToken.scopes) === null || _storedToken$scopes === void 0 ? void 0 : _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}
-     */
-  }, {
-    key: "_validateAgainstUser",
-    value: (
-    /**
-     * Check scopes
-     * @param {StoredToken} storedToken
-     * @return {Promise.<StoredToken>}
-     * @private
-     */
-    function () {
-      var _validateAgainstUser2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(storedToken) {
-        var response, _errorResponse$data, _errorResponse$data2;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              _context.prev = 0;
-              _context.next = 3;
-              return this._getUser(storedToken.accessToken);
-            case 3:
-              return _context.abrupt("return", _context.sent);
-            case 6:
-              _context.prev = 6;
-              _context.t0 = _context["catch"](0);
-              response = {};
-              _context.prev = 9;
-              _context.next = 12;
-              return _context.t0.response.json();
-            case 12:
-              response = _context.sent;
-              _context.next = 17;
-              break;
-            case 15:
-              _context.prev = 15;
-              _context.t1 = _context["catch"](9);
-            case 17:
-              if (!(_context.t0.status === CODE.UNAUTHORIZED || TokenValidator.shouldRefreshToken(response.error))) {
-                _context.next = 19;
-                break;
-              }
-              throw new TokenValidator.TokenValidationError(response.error || _context.t0.message, (_errorResponse$data = _context.t0.data) !== null && _errorResponse$data !== void 0 && _errorResponse$data.error ? new Error((_errorResponse$data2 = _context.t0.data) === null || _errorResponse$data2 === void 0 ? void 0 : _errorResponse$data2.error) : undefined);
-            case 19:
-              throw _context.t0;
-            case 20:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this, [[0, 6], [9, 15]]);
-      }));
-      function _validateAgainstUser(_x) {
-        return _validateAgainstUser2.apply(this, arguments);
+  }
+  /**
+   * 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);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (errorResponse) {
+      let response = {};
+      try {
+        response = await errorResponse.response.json();
+      } catch (e) {
+        // Skip JSON parsing errors
       }
-      return _validateAgainstUser;
-    }()
-    /**
-     * 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
-     */
-    )
-  }, {
-    key: "_getValidatedToken",
-    value: (function () {
-      var _getValidatedToken2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(validators) {
-        var storedToken, i;
-        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              _context2.next = 2;
-              return this._storage.getToken();
-            case 2:
-              storedToken = _context2.sent;
-              if (!(storedToken == null)) {
-                _context2.next = 5;
-                break;
-              }
-              throw new TokenValidator.TokenValidationError('Token not found');
-            case 5:
-              i = 0;
-            case 6:
-              if (!(i < validators.length)) {
-                _context2.next = 12;
-                break;
-              }
-              _context2.next = 9;
-              return validators[i](storedToken);
-            case 9:
-              i++;
-              _context2.next = 6;
-              break;
-            case 12:
-              return _context2.abrupt("return", storedToken.accessToken);
-            case 13:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this);
-      }));
-      function _getValidatedToken(_x2) {
-        return _getValidatedToken2.apply(this, arguments);
+      if (errorResponse.status === CODE.UNAUTHORIZED || TokenValidator.shouldRefreshToken(response.error)) {
+        var _errorResponse$data, _errorResponse$data2;
+        // Token expired
+        throw new TokenValidator.TokenValidationError(response.error || errorResponse.message, (_errorResponse$data = errorResponse.data) !== null && _errorResponse$data !== void 0 && _errorResponse$data.error ? new Error((_errorResponse$data2 = errorResponse.data) === null || _errorResponse$data2 === void 0 ? void 0 : _errorResponse$data2.error) : undefined);
       }
-      return _getValidatedToken;
-    }())
-  }], [{
-    key: "_epoch",
-    value: function _epoch() {
-      var milliseconds = 1000.0;
-      return Math.round(Date.now() / milliseconds);
+      // Request unexpectedly failed
+      throw errorResponse;
     }
-    /**
-     * @const {number}
-     */
-    // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-  }, {
-    key: "_validateExistence",
-    value: function _validateExistence(storedToken) {
-      if (!storedToken || !storedToken.accessToken) {
-        throw new TokenValidator.TokenValidationError('Token not found');
-      }
-    }
-    /**
-     * Check expiration
-     * @param {StoredToken} storedToken
-     * @return {Promise.<StoredToken>}
-     * @private
-     */
-  }, {
-    key: "_validateExpiration",
-    value: function _validateExpiration(_ref) {
-      var expires = _ref.expires,
-        lifeTime = _ref.lifeTime;
-      var REFRESH_BEFORE_RATIO = 6;
-      var refreshBefore = lifeTime ? Math.ceil(lifeTime / REFRESH_BEFORE_RATIO) : TokenValidator.DEFAULT_REFRESH_BEFORE;
-      if (expires && expires < TokenValidator._epoch() + refreshBefore) {
-        throw new TokenValidator.TokenValidationError('Token expired');
-      }
+  }
+  /**
+   * 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();
+    if (storedToken == null) {
+      throw new TokenValidator.TokenValidationError('Token not found');
     }
-  }, {
-    key: "shouldRefreshToken",
-    value: function shouldRefreshToken(error) {
-      return error === 'invalid_grant' || error === 'invalid_request' || error === 'invalid_token';
+    for (let i = 0; i < validators.length; i++) {
+      await validators[i](storedToken);
     }
-  }]);
-}();
+    return storedToken.accessToken;
+  }
+}
 _defineProperty(TokenValidator, "DEFAULT_REFRESH_BEFORE", 10 * 60);
 // 20 min in s
 /**

package/components/auth/window-flow.js

@@ -1,41 +1,32 @@
-import { b as _createClass, e as _classCallCheck, _ as _defineProperty, g as _asyncToGenerator, h as _regeneratorRuntime } from '../_helpers/_rollupPluginBabelHelpers.js';
-import 'core-js/modules/es.array.concat.js';
-import 'core-js/modules/es.object.to-string.js';
-import 'core-js/modules/es.promise.js';
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
 import AuthResponseParser from './response-parser.js';
-import 'core-js/modules/es.array.index-of.js';
 import 'core-js/modules/es.regexp.exec.js';
-import 'core-js/modules/es.regexp.to-string.js';
 import 'core-js/modules/es.string.replace.js';
-import 'core-js/modules/web.dom-collections.for-each.js';
 import 'es6-error';
 import '../global/url.js';
-import 'core-js/modules/es.string.match.js';
 
-var NAVBAR_HEIGHT = 50;
-var CLOSED_CHECK_INTERVAL = 200;
-var WindowFlow = /*#__PURE__*/function () {
-  function WindowFlow(requestBuilder, storage) {
-    var _this = this;
-    _classCallCheck(this, WindowFlow);
+const NAVBAR_HEIGHT = 50;
+const CLOSED_CHECK_INTERVAL = 200;
+class WindowFlow {
+  constructor(requestBuilder, storage) {
     _defineProperty(this, "_timeoutId", undefined);
     _defineProperty(this, "_requestBuilder", void 0);
     _defineProperty(this, "_storage", void 0);
     _defineProperty(this, "reject", void 0);
     _defineProperty(this, "_loginWindow", void 0);
     _defineProperty(this, "_promise", void 0);
-    _defineProperty(this, "checkIsClosed", function () {
+    _defineProperty(this, "checkIsClosed", () => {
       var _this$_loginWindow;
-      if ((_this$_loginWindow = _this._loginWindow) !== null && _this$_loginWindow !== void 0 && _this$_loginWindow.closed) {
-        _this.stop();
+      if ((_this$_loginWindow = this._loginWindow) !== null && _this$_loginWindow !== void 0 && _this$_loginWindow.closed) {
+        this.stop();
         return;
       }
-      _this._timeoutId = window.setTimeout(_this.checkIsClosed, CLOSED_CHECK_INTERVAL);
+      this._timeoutId = window.setTimeout(this.checkIsClosed, CLOSED_CHECK_INTERVAL);
     });
-    _defineProperty(this, "_reset", function () {
-      _this._promise = null;
-      _this._loginWindow = null;
-      clearTimeout(_this._timeoutId);
+    _defineProperty(this, "_reset", () => {
+      this._promise = null;
+      this._loginWindow = null;
+      clearTimeout(this._timeoutId);
     });
     this._requestBuilder = requestBuilder;
     this._storage = storage;
@@ -46,108 +37,80 @@ var WindowFlow = /*#__PURE__*/function () {
    * @param {string} url
    * @private
    */
-  return _createClass(WindowFlow, [{
-    key: "_openWindow",
-    value: function _openWindow(url) {
-      var height = 700;
-      var width = 750;
-      var screenHalves = 2;
-      var top = (window.screen.height - height - NAVBAR_HEIGHT) / screenHalves;
-      var 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
-     */
-  }, {
-    key: "_load",
-    value: (function () {
-      var _load2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-        var _this2 = this;
-        var authRequest;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              _context.next = 2;
-              return this._requestBuilder.prepareAuthRequest(
-              // eslint-disable-next-line camelcase
-              {
-                request_credentials: 'required',
-                auth_mode: 'bypass_to_login'
-              }, {
-                nonRedirect: true
-              });
-            case 2:
-              authRequest = _context.sent;
-              return _context.abrupt("return", new Promise(function (resolve, reject) {
-                _this2.reject = reject;
-                var cleanRun;
-                var cleanUp = function cleanUp() {
-                  var _this2$_loginWindow;
-                  if (cleanRun) {
-                    return;
-                  }
-                  cleanRun = true;
-                  /* eslint-disable @typescript-eslint/no-use-before-define */
-                  removeStateListener();
-                  removeTokenListener();
-                  /* eslint-enable @typescript-eslint/no-use-before-define */
-                  (_this2$_loginWindow = _this2._loginWindow) === null || _this2$_loginWindow === void 0 || _this2$_loginWindow.close();
-                  clearTimeout(_this2._timeoutId);
-                };
-                var removeTokenListener = _this2._storage.onTokenChange(function (token) {
-                  if (token) {
-                    cleanUp();
-                    resolve(token.accessToken);
-                  }
-                });
-                var removeStateListener = _this2._storage.onStateChange(authRequest.stateId, function (state) {
-                  if (state && state.error) {
-                    cleanUp();
-                    reject(new AuthResponseParser.AuthError(state));
-                  }
-                });
-                if (_this2._loginWindow == null || _this2._loginWindow.closed) {
-                  _this2._loginWindow = _this2._openWindow(authRequest.url);
-                } else {
-                  _this2._loginWindow.location.href = authRequest.url;
-                }
-                _this2.checkIsClosed();
-              }));
-            case 4:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this);
-      }));
-      function _load() {
-        return _load2.apply(this, arguments);
-      }
-      return _load;
-    }())
-  }, {
-    key: "stop",
-    value: function stop() {
-      if (this._loginWindow != null) {
-        this._loginWindow.close();
-      }
-      if (this.reject) {
-        this.reject('Authorization window closed');
+  _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 = () => {
+        var _this$_loginWindow2;
+        if (cleanRun) {
+          return;
+        }
+        cleanRun = true;
+        /* eslint-disable @typescript-eslint/no-use-before-define */
+        removeStateListener();
+        removeTokenListener();
+        /* eslint-enable @typescript-eslint/no-use-before-define */
+        (_this$_loginWindow2 = this._loginWindow) === null || _this$_loginWindow2 === void 0 || _this$_loginWindow2.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) {
+        this._loginWindow = this._openWindow(authRequest.url);
+      } else {
+        this._loginWindow.location.href = authRequest.url;
       }
-      this._reset();
+      this.checkIsClosed();
+    });
+  }
+  stop() {
+    if (this._loginWindow != null) {
+      this._loginWindow.close();
     }
-  }, {
-    key: "authorize",
-    value: function authorize() {
-      if (this._promise != null && this._loginWindow != null && !this._loginWindow.closed) {
-        this._loginWindow.focus();
-        return this._promise;
-      }
-      this._promise = this._load();
-      this._promise.then(this._reset, this._reset);
+    if (this.reject) {
+      this.reject('Authorization window closed');
+    }
+    this._reset();
+  }
+  authorize() {
+    if (this._promise != null && this._loginWindow != null && !this._loginWindow.closed) {
+      this._loginWindow.focus();
       return this._promise;
     }
-  }]);
-}();
+    this._promise = this._load();
+    this._promise.then(this._reset, this._reset);
+    return this._promise;
+  }
+}
 
 export { WindowFlow as default };