@jetbrains/ring-ui-built 6.0.32 → 6.0.34

package/components/auth/token-validator.js

@@ -1,21 +1,44 @@
+import { _ as _defineProperty, a as _inherits, b as _createClass, f as _classCallCheck, g as _callSuper, h as _asyncToGenerator, i 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 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';
 
-class TokenValidationError extends ExtendableError {
-  cause;
-  authRedirect;
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-    this.authRedirect = true;
+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 TokenValidator {
-  _getUser;
-  _config;
-  _storage;
-  constructor(config, getUser, storage) {
+  _inherits(TokenValidationError, _ExtendableError);
+  return _createClass(TokenValidationError);
+}(ExtendableError);
+var TokenValidator = /*#__PURE__*/function () {
+  function TokenValidator(config, getUser, storage) {
+    _classCallCheck(this, TokenValidator);
+    _defineProperty(this, "_getUser", void 0);
+    _defineProperty(this, "_config", void 0);
+    _defineProperty(this, "_storage", void 0);
     this._getUser = getUser;
     this._config = config;
     this._storage = storage;
@@ -26,137 +49,219 @@ class TokenValidator {
    * @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 @typescript-eslint/no-magic-numbers
-  static DEFAULT_REFRESH_BEFORE = 10 * 60; // 20 min in s
-  /**
-   * Error class for auth token validation
-   *
-   * @param {string} message Error message
-   * @param {Error=} cause Error that caused this error
-   */
-  static TokenValidationError = TokenValidationError;
-  /**
-   * 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');
+  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)]);
     }
-  }
-  /**
-   * 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 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 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 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 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
+    /**
+     * 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);
       }
-      if (errorResponse.status === CODE.UNAUTHORIZED || TokenValidator.shouldRefreshToken(response.error)) {
-        // Token expired
-        throw new TokenValidator.TokenValidationError(response.error || errorResponse.message, errorResponse.data?.error ? new Error(errorResponse.data?.error) : undefined);
+      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);
       }
-      // Request unexpectedly failed
-      throw errorResponse;
+      return _getValidatedToken;
+    }())
+  }], [{
+    key: "_epoch",
+    value: function _epoch() {
+      var milliseconds = 1000.0;
+      return Math.round(Date.now() / milliseconds);
     }
-  }
-  /**
-   * 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');
+    /**
+     * @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');
+      }
     }
-    for (let i = 0; i < validators.length; i++) {
-      await validators[i](storedToken);
+    /**
+     * 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');
+      }
     }
-    return storedToken.accessToken;
-  }
-}
+  }, {
+    key: "shouldRefreshToken",
+    value: function shouldRefreshToken(error) {
+      return error === 'invalid_grant' || error === 'invalid_request' || error === 'invalid_token';
+    }
+  }]);
+}();
+_defineProperty(TokenValidator, "DEFAULT_REFRESH_BEFORE", 10 * 60);
+// 20 min in s
+/**
+ * Error class for auth token validation
+ *
+ * @param {string} message Error message
+ * @param {Error=} cause Error that caused this error
+ */
+_defineProperty(TokenValidator, "TokenValidationError", TokenValidationError);
 
 export { TokenValidationError, TokenValidator as default };

package/components/auth/window-flow.js

@@ -1,17 +1,42 @@
+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.concat.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.promise.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';
 
-const NAVBAR_HEIGHT = 50;
-const CLOSED_CHECK_INTERVAL = 200;
-class WindowFlow {
-  _timeoutId = undefined;
-  _requestBuilder;
-  _storage;
-  reject;
-  _loginWindow;
-  _promise;
-  constructor(requestBuilder, storage) {
+var NAVBAR_HEIGHT = 50;
+var CLOSED_CHECK_INTERVAL = 200;
+var WindowFlow = /*#__PURE__*/function () {
+  function WindowFlow(requestBuilder, storage) {
+    var _this = this;
+    _classCallCheck(this, WindowFlow);
+    _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 () {
+      var _this$_loginWindow;
+      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);
+    });
+    _defineProperty(this, "_reset", function () {
+      _this._promise = null;
+      _this._loginWindow = null;
+      clearTimeout(_this._timeoutId);
+    });
     this._requestBuilder = requestBuilder;
     this._storage = storage;
     this._reset();
@@ -21,91 +46,108 @@ class WindowFlow {
    * @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=${height}, width=${width}, left=${left}, top=${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 @typescript-eslint/no-use-before-define */
-        removeStateListener();
-        removeTokenListener();
-        /* eslint-enable @typescript-eslint/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) {
-        this._loginWindow = this._openWindow(authRequest.url);
-      } else {
-        this._loginWindow.location.href = authRequest.url;
-      }
-      this.checkIsClosed();
-    });
-  }
-  checkIsClosed = () => {
-    if (this._loginWindow?.closed) {
-      this.stop();
-      return;
-    }
-    this._timeoutId = window.setTimeout(this.checkIsClosed, CLOSED_CHECK_INTERVAL);
-  };
-  _reset = () => {
-    this._promise = null;
-    this._loginWindow = null;
-    clearTimeout(this._timeoutId);
-  };
-  stop() {
-    if (this._loginWindow != null) {
-      this._loginWindow.close();
+  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));
     }
-    if (this.reject) {
-      this.reject('Authorization window closed');
+    /**
+     * 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');
+      }
+      this._reset();
     }
-    this._reset();
-  }
-  authorize() {
-    if (this._promise != null && this._loginWindow != null && !this._loginWindow.closed) {
-      this._loginWindow.focus();
+  }, {
+    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);
       return this._promise;
     }
-    this._promise = this._load();
-    this._promise.then(this._reset, this._reset);
-    return this._promise;
-  }
-}
+  }]);
+}();
 
 export { WindowFlow as default };