@jetbrains/ring-ui-built 6.0.32 → 6.0.33

package/components/auth/request-builder.js

@@ -1,9 +1,15 @@
+import { _ as _defineProperty, b as _createClass, f as _classCallCheck, h as _asyncToGenerator, i as _regeneratorRuntime } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.object.assign.js';
 import uuid from 'simply-uuid';
 import { encodeURL } from '../global/url.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.array.index-of.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 AuthRequestBuilder {
-  config;
-  storage;
+var AuthRequestBuilder = /*#__PURE__*/function () {
   /**
    * @param {{
    *   authorization: string,
@@ -14,54 +20,84 @@ class AuthRequestBuilder {
    * }} config
    * @param {AuthStorage} storage
    */
-  constructor(config, storage) {
+  function AuthRequestBuilder(config, storage) {
+    _classCallCheck(this, AuthRequestBuilder);
+    _defineProperty(this, "config", void 0);
+    _defineProperty(this, "storage", void 0);
     this.config = config;
     this.storage = storage;
   }
   /**
    * @return {string} random string used for state
    */
-  static _uuid = uuid.generate;
-  /**
-   * Save state and build an auth server redirect URL.
-   *
-   * @param {object=} extraParams additional query parameters for auth request
-   * @param {object=} extraState additional state parameters to save
-   * @return {Promise.<string>} promise that is resolved to authURL
-   */
-  async prepareAuthRequest(extraParams, extraState) {
-    const stateId = AuthRequestBuilder._uuid();
-    const scopes = this.config.scopes.map(scope => encodeURIComponent(scope));
-    /* eslint-disable camelcase */
-    const request = Object.assign({
-      response_type: 'token',
-      state: stateId,
-      redirect_uri: this.config.redirectUri,
-      request_credentials: this.config.requestCredentials,
-      client_id: this.config.clientId,
-      scope: scopes.join(' ')
-    }, extraParams || {});
-    /* eslint-enable camelcase */
-    const authURL = encodeURL(this.config.authorization, request);
-    const state = Object.assign({
-      restoreLocation: window.location.href,
-      scopes: this.config.scopes
-    }, extraState || {});
-    await this._saveState(stateId, state);
-    return {
-      url: authURL,
-      stateId
-    };
-  }
-  /**
-   * @param {string} id
-   * @param {StoredState} storedState
-   * @return {Promise}
-   * @private
-   */
-  _saveState(id, storedState) {
-    return this.storage?.saveState(id, storedState);
-  }
-}
+  return _createClass(AuthRequestBuilder, [{
+    key: "prepareAuthRequest",
+    value: (
+    /**
+     * Save state and build an auth server redirect URL.
+     *
+     * @param {object=} extraParams additional query parameters for auth request
+     * @param {object=} extraState additional state parameters to save
+     * @return {Promise.<string>} promise that is resolved to authURL
+     */
+    function () {
+      var _prepareAuthRequest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(extraParams, extraState) {
+        var stateId, scopes, request, authURL, state;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              stateId = AuthRequestBuilder._uuid();
+              scopes = this.config.scopes.map(function (scope) {
+                return encodeURIComponent(scope);
+              });
+              /* eslint-disable camelcase */
+              request = Object.assign({
+                response_type: 'token',
+                state: stateId,
+                redirect_uri: this.config.redirectUri,
+                request_credentials: this.config.requestCredentials,
+                client_id: this.config.clientId,
+                scope: scopes.join(' ')
+              }, extraParams || {});
+              /* eslint-enable camelcase */
+              authURL = encodeURL(this.config.authorization, request);
+              state = Object.assign({
+                restoreLocation: window.location.href,
+                scopes: this.config.scopes
+              }, extraState || {});
+              _context.next = 7;
+              return this._saveState(stateId, state);
+            case 7:
+              return _context.abrupt("return", {
+                url: authURL,
+                stateId
+              });
+            case 8:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function prepareAuthRequest(_x, _x2) {
+        return _prepareAuthRequest.apply(this, arguments);
+      }
+      return prepareAuthRequest;
+    }()
+    /**
+     * @param {string} id
+     * @param {StoredState} storedState
+     * @return {Promise}
+     * @private
+     */
+    )
+  }, {
+    key: "_saveState",
+    value: function _saveState(id, storedState) {
+      var _this$storage;
+      return (_this$storage = this.storage) === null || _this$storage === void 0 ? void 0 : _this$storage.saveState(id, storedState);
+    }
+  }]);
+}();
+_defineProperty(AuthRequestBuilder, "_uuid", uuid.generate);
 
 export { AuthRequestBuilder as default };

package/components/auth/response-parser.js

@@ -1,19 +1,33 @@
+import { _ as _defineProperty, a as _inherits, b as _createClass, d as _objectSpread2, f as _classCallCheck, g as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.index-of.js';
+import 'core-js/modules/es.object.to-string.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 ExtendableError from 'es6-error';
 import { parseQueryString } from '../global/url.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.string.match.js';
 
-class AuthError extends ExtendableError {
-  code;
-  uri;
-  stateId;
+var AuthError = /*#__PURE__*/function (_ExtendableError) {
   // Supports weird IE 11 failing test issue
-  constructor() {
-    let authResponse = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    super(authResponse.errorDescription);
-    this.code = authResponse.error;
-    this.uri = authResponse.errorUri;
-    this.stateId = authResponse.state;
+  function AuthError() {
+    var _this;
+    var authResponse = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, AuthError);
+    _this = _callSuper(this, AuthError, [authResponse.errorDescription]);
+    _defineProperty(_this, "code", void 0);
+    _defineProperty(_this, "uri", void 0);
+    _defineProperty(_this, "stateId", void 0);
+    _this.code = authResponse.error;
+    _this.uri = authResponse.errorUri;
+    _this.stateId = authResponse.state;
+    return _this;
   }
-}
+  _inherits(AuthError, _ExtendableError);
+  return _createClass(AuthError);
+}(ExtendableError);
 /**
  * @typedef {Object} AuthResponse
  * @property {?string} accessToken
@@ -23,84 +37,100 @@ class AuthError extends ExtendableError {
  * @property {?string} scope
  * @property {?string} error
  */
-class AuthResponseParser {
-  _authResponse;
-  constructor() {
+var AuthResponseParser = /*#__PURE__*/function () {
+  function AuthResponseParser() {
+    _classCallCheck(this, AuthResponseParser);
+    _defineProperty(this, "_authResponse", void 0);
     this._authResponse = this.readAuthResponseFromURL();
   }
-  static AuthError = AuthError;
-  static convertKey(key) {
-    return key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-  }
-  /**
-   * Check if the hash contains an access token.
-   * If it does, return auth response. Otherwise return undefined.
-   * Always clears the hash part of the URL.
-   *
-   * @throws {Error} if the auth server returned an error
-   * @return {?AuthResponse}
-   */
-  getAuthResponseFromURL() {
-    return this.validateAuthResponse(this._authResponse);
-  }
-  /**
-   * Validates given authResponse.
-   * If it contains a token - returns the token, if an error is found - throws the error,
-   * otherwise - null
-   * Always clears the hash part of the URL.
-   *
-   * @param authResponse {AuthResponse} parsed authResponse
-   * @throws {Error} if the auth server returned an error
-   * @return {?AuthResponse}
-   */
-  validateAuthResponse(authResponse) {
-    // Check for errors
-    if (authResponse.error) {
-      throw new AuthResponseParser.AuthError(authResponse);
+  return _createClass(AuthResponseParser, [{
+    key: "getAuthResponseFromURL",
+    value:
+    /**
+     * Check if the hash contains an access token.
+     * If it does, return auth response. Otherwise return undefined.
+     * Always clears the hash part of the URL.
+     *
+     * @throws {Error} if the auth server returned an error
+     * @return {?AuthResponse}
+     */
+    function getAuthResponseFromURL() {
+      return this.validateAuthResponse(this._authResponse);
     }
-    // If there is no token in the hash
-    if (!authResponse.accessToken) {
-      return null;
-    }
-    return {
-      ...authResponse,
-      accessToken: authResponse.accessToken
-    };
-  }
-  /**
-   * Reads the current accessToken from the URL.
-   * Doesn't modify URL
-   *
-   * @return {AuthResponse}
-   */
-  readAuthResponseFromURL() {
-    const authResponse = {};
-    const rawAuthResponse = parseQueryString(this.getHash());
-    Object.keys(rawAuthResponse).forEach(key => {
-      if (key.indexOf('_') !== -1) {
-        authResponse[AuthResponseParser.convertKey(key)] = rawAuthResponse[key];
-        return;
+    /**
+     * Validates given authResponse.
+     * If it contains a token - returns the token, if an error is found - throws the error,
+     * otherwise - null
+     * Always clears the hash part of the URL.
+     *
+     * @param authResponse {AuthResponse} parsed authResponse
+     * @throws {Error} if the auth server returned an error
+     * @return {?AuthResponse}
+     */
+  }, {
+    key: "validateAuthResponse",
+    value: function validateAuthResponse(authResponse) {
+      // Check for errors
+      if (authResponse.error) {
+        throw new AuthResponseParser.AuthError(authResponse);
       }
-      authResponse[key] = rawAuthResponse[key];
-    });
-    return authResponse;
-  }
-  /**
-   * @return {string} part of the URL after # sign.
-   * @private
-   */
-  getHash() {
-    // Because of stupid Firefox bug — https://bugzilla.mozilla.org/show_bug.cgi?id=483304
-    const location = this.getLocation();
-    return location && location.replace(/^[^#]*#?/, '');
-  }
-  /**
-   * Current page location.
-   * @return {string}
-   */
-  getLocation() {
-    return window.location.toString();
-  }
-}
+      // If there is no token in the hash
+      if (!authResponse.accessToken) {
+        return null;
+      }
+      return _objectSpread2(_objectSpread2({}, authResponse), {}, {
+        accessToken: authResponse.accessToken
+      });
+    }
+    /**
+     * Reads the current accessToken from the URL.
+     * Doesn't modify URL
+     *
+     * @return {AuthResponse}
+     */
+  }, {
+    key: "readAuthResponseFromURL",
+    value: function readAuthResponseFromURL() {
+      var authResponse = {};
+      var rawAuthResponse = parseQueryString(this.getHash());
+      Object.keys(rawAuthResponse).forEach(function (key) {
+        if (key.indexOf('_') !== -1) {
+          authResponse[AuthResponseParser.convertKey(key)] = rawAuthResponse[key];
+          return;
+        }
+        authResponse[key] = rawAuthResponse[key];
+      });
+      return authResponse;
+    }
+    /**
+     * @return {string} part of the URL after # sign.
+     * @private
+     */
+  }, {
+    key: "getHash",
+    value: function getHash() {
+      // Because of stupid Firefox bug — https://bugzilla.mozilla.org/show_bug.cgi?id=483304
+      var location = this.getLocation();
+      return location && location.replace(/^[^#]*#?/, '');
+    }
+    /**
+     * Current page location.
+     * @return {string}
+     */
+  }, {
+    key: "getLocation",
+    value: function getLocation() {
+      return window.location.toString();
+    }
+  }], [{
+    key: "convertKey",
+    value: function convertKey(key) {
+      return key.replace(/_([a-z])/g, function (_, letter) {
+        return letter.toUpperCase();
+      });
+    }
+  }]);
+}();
+_defineProperty(AuthResponseParser, "AuthError", AuthError);
 
 export { AuthError, AuthResponseParser as default };