@jetbrains/ring-ui 4.1.1 → 4.1.2

package/dist/auth/background-flow.js

@@ -0,0 +1,122 @@
+import AuthResponseParser from './response-parser.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'es6-error';
+import '../global/url.js';
+
+const HUB_AUTH_PAGE_OPENED = 'HUB_AUTH_PAGE_OPENED';
+class BackgroundFlow {
+  constructor(requestBuilder, storage, timeout) {
+    this._requestBuilder = requestBuilder;
+    this._storage = storage;
+    this._timeout = timeout;
+  }
+  /**
+   * Creates a hidden iframe
+   * @return {HTMLIFrameElement}
+   * @private
+   */
+
+
+  _createHiddenFrame() {
+    const iframe = document.createElement('iframe');
+    iframe.style.border = iframe.style.width = iframe.style.height = '0px';
+    iframe.style.visibility = 'hidden';
+    iframe.style.position = 'fixed';
+    iframe.style.left = '-10000px';
+    window.document.body.appendChild(iframe);
+    return iframe;
+  }
+  /**
+   * Redirects the given iframe to the given URL
+   * @param {HTMLIFrameElement} iframe
+   * @param {string} url
+   * @private
+   */
+
+
+  _redirectFrame(iframe, url) {
+    iframe.src = `${url}&rnd=${Math.random()}`;
+  }
+  /**
+   * Refreshes the access token in an iframe.
+   *
+   * @return {Promise.<string>} promise that is resolved to access the token when it is loaded in a background iframe. The
+   * promise is rejected if no token was received after {@link BackgroundToken.BACKGROUND_TIMEOUT} ms.
+   */
+
+
+  async _load() {
+    const authRequest = await this._requestBuilder. // eslint-disable-next-line camelcase
+    prepareAuthRequest({
+      request_credentials: 'silent'
+    }, {
+      nonRedirect: true
+    });
+    return new Promise((resolve, reject) => {
+      function onMessage(e) {
+        if (e.data === HUB_AUTH_PAGE_OPENED) {
+          reject(new Error('Failed to obtain/refresh token in background'));
+          cleanUp();
+        }
+      }
+
+      window.addEventListener('message', onMessage);
+
+      const iframe = this._createHiddenFrame();
+
+      let cleanRun;
+      const timeout = setTimeout(() => {
+        reject(new Error('Failed to refresh authorization'));
+        cleanUp();
+      }, this._timeout);
+
+      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));
+        }
+      });
+
+      function cleanUp() {
+        if (cleanRun) {
+          return;
+        }
+
+        cleanRun = true;
+        clearTimeout(timeout);
+        removeStateListener();
+        removeTokenListener();
+        window.removeEventListener('message', onMessage);
+        window.document.body.removeChild(iframe);
+      }
+
+      this._redirectFrame(iframe, authRequest.url);
+    });
+  }
+
+  authorize() {
+    if (this._promise) {
+      return this._promise;
+    }
+
+    const resetPromise = () => {
+      this._promise = null;
+    };
+
+    this._promise = this._load();
+
+    this._promise.then(resetPromise, resetPromise);
+
+    return this._promise;
+  }
+
+}
+
+export { HUB_AUTH_PAGE_OPENED, BackgroundFlow as default };

package/dist/auth/down-notification.js

@@ -0,0 +1,114 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import alertService from '../alert-service/alert-service.js';
+import Alert from '../alert/alert.js';
+import Link from '../link/link.js';
+import Group from '../group/group.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'react-dom';
+import '../global/get-uid.js';
+import '../alert/container.js';
+import 'classnames';
+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 '../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 'focus-visible';
+import '../link/clickableLink.js';
+import '../_helpers/link.js';
+import '../_helpers/group.js';
+
+var modules_c87dd562 = {"unit":"8px","title":"title_rui_dc35","error":"error_rui_dc35"};
+
+let key = null;
+
+function renderAlert(message) {
+  let type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Alert.Type.WARNING;
+  const existingAlert = alertService.showingAlerts.filter(alert => alert.key === key)[0];
+
+  if (!existingAlert) {
+    key = alertService.addAlert(message, type, 0, {
+      closeable: false
+    });
+  } else {
+    existingAlert.message = message;
+    existingAlert.type = type;
+    alertService.renderAlerts();
+  }
+}
+
+function Message(_ref) {
+  let {
+    translations,
+    onCheckAgain
+  } = _ref;
+  const {
+    backendIsNotAvailable,
+    checkAgain,
+    errorMessage
+  } = translations;
+  return /*#__PURE__*/React.createElement("div", {
+    "data-test": "ring-backend-down-notification"
+  }, /*#__PURE__*/React.createElement(Group, null, /*#__PURE__*/React.createElement("div", {
+    className: modules_c87dd562.title
+  }, backendIsNotAvailable)), /*#__PURE__*/React.createElement("span", {
+    className: modules_c87dd562.error
+  }, errorMessage, " "), /*#__PURE__*/React.createElement(Link, {
+    onClick: onCheckAgain,
+    "data-test": "check-again"
+  }, checkAgain));
+}
+
+Message.propTypes = {
+  translations: PropTypes.shape({
+    backendIsNotAvailable: PropTypes.string,
+    checkAgain: PropTypes.string,
+    errorMessage: PropTypes.string
+  }),
+  onCheckAgain: PropTypes.func
+};
+function onBackendDown(_ref2) {
+  let {
+    onCheckAgain,
+    translations
+  } = _ref2;
+
+  async function checkAgainWithoutClosing(e) {
+    // Alert has weird behaviour of handling clicks by "a" tags
+    e.stopPropagation();
+
+    try {
+      renderAlert('Connecting...', Alert.Type.LOADING);
+      await onCheckAgain();
+    } catch (err) {
+      renderAlert( /*#__PURE__*/React.createElement(Message, {
+        translations: translations,
+        onCheckAgain: checkAgainWithoutClosing
+      }));
+    }
+  }
+
+  renderAlert( /*#__PURE__*/React.createElement(Message, {
+    translations: translations,
+    onCheckAgain: checkAgainWithoutClosing
+  }));
+  return () => alertService.remove(key);
+}
+
+export { onBackendDown as default };

package/dist/auth/iframe-flow.js

@@ -0,0 +1,150 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React from 'react';
+import showAuthDialog from '../login-dialog/service.js';
+import Link from '../link/link.js';
+import AuthResponseParser from './response-parser.js';
+import 'react-dom';
+import '../login-dialog/login-dialog.js';
+import 'prop-types';
+import '../dialog/dialog.js';
+import 'classnames';
+import '@jetbrains/icons/close';
+import '../island/island.js';
+import '../global/data-tests.js';
+import '../island/adaptive-island-hoc.js';
+import '../global/linear-function.js';
+import '../_helpers/island.js';
+import '../island/header.js';
+import '../island/content.js';
+import 'element-resize-detector';
+import '../global/schedule-raf.js';
+import '../global/get-uid.js';
+import '../shortcuts/shortcuts.js';
+import '../shortcuts/core.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+import '../tab-trap/tab-trap.js';
+import '../global/dom.js';
+import '../button/button.js';
+import 'focus-visible';
+import '@jetbrains/icons/chevron-10px';
+import '../icon/icon.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon.js';
+import '../icon/icon__svg.js';
+import '../global/memoize.js';
+import '../global/theme.js';
+import '../link/clickableLink.js';
+import '../_helpers/button__classes.js';
+import '../popup/popup.target.js';
+import '../_helpers/dialog__body-scroll-preventer.js';
+import 'scrollbar-width';
+import '../loader-screen/loader-screen.js';
+import '../loader/loader.js';
+import '../loader/loader__core.js';
+import '../_helpers/loader-screen.js';
+import './background-flow.js';
+import 'es6-error';
+import '../global/url.js';
+import '../_helpers/link.js';
+
+class IFrameFlow {
+  constructor(requestBuilder, storage, translations) {
+    _defineProperty(this, "hideDialog", null);
+
+    _defineProperty(this, "_reset", () => {
+      this._promise = null;
+      this.hideDialog = null;
+    });
+
+    this._requestBuilder = requestBuilder;
+    this._storage = storage;
+    this._translations = translations;
+
+    this._reset();
+  }
+  /**
+   * 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: false
+    });
+
+    const renderFallbackLink = () => /*#__PURE__*/React.createElement(Link, {
+      href: authRequest.url,
+      target: "_self"
+    }, this._translations.nothingHappensLink);
+
+    return new Promise((resolve, reject) => {
+      this.hideDialog = showAuthDialog({
+        url: authRequest.url,
+        loader: true,
+        onCancel: () => {
+          // eslint-disable-next-line no-use-before-define
+          cleanUp();
+          this.stop();
+        },
+        renderFallbackLink
+      });
+      this.reject = reject;
+
+      const removeTokenListener = this._storage.onTokenChange(token => {
+        if (token) {
+          // eslint-disable-next-line no-use-before-define
+          cleanUp();
+          resolve(token.accessToken);
+        }
+      });
+
+      const removeStateListener = this._storage.onStateChange(authRequest.stateId, state => {
+        if (state && state.error) {
+          // eslint-disable-next-line no-use-before-define
+          cleanUp();
+          reject(new AuthResponseParser.AuthError(state));
+        }
+      });
+
+      const cleanUp = () => {
+        this.hideDialog();
+        removeStateListener();
+        removeTokenListener();
+      };
+    });
+  }
+
+  stop() {
+    if (this.hideDialog) {
+      this.hideDialog();
+    }
+
+    if (this.reject) {
+      this.reject('Login form closed');
+    }
+
+    this._reset();
+  }
+
+  authorize() {
+    if (this._promise !== null && this._loginWindow !== null && this._loginWindow.closed !== true) {
+      return this._promise;
+    }
+
+    this._promise = this._load();
+
+    this._promise.then(this._reset, this._reset);
+
+    return this._promise;
+  }
+
+}
+
+export { IFrameFlow as default };

package/dist/auth/landing-entry.js

@@ -0,0 +1,5 @@
+import '!!file-loader?publicPath=../../&name=auth-landing.html!extricate-loader!interpolate-loader!./landing.html';
+
+var landingEntry = 'auth-landing.html';
+
+export { landingEntry as default };

package/dist/auth/landing.js

@@ -0,0 +1,87 @@
+import TokenValidator from './token-validator.js';
+import AuthResponseParser from './response-parser.js';
+import './auth.js';
+import AuthStorage from './storage.js';
+import { DEFAULT_EXPIRES_TIMEOUT } from './auth__core.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'es6-error';
+import '../http/http.js';
+import '../global/url.js';
+import './window-flow.js';
+import './down-notification.js';
+import 'react';
+import 'prop-types';
+import '../alert-service/alert-service.js';
+import 'react-dom';
+import '../global/get-uid.js';
+import '../alert/alert.js';
+import 'classnames';
+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 '../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 '../link/link.js';
+import 'focus-visible';
+import '../link/clickableLink.js';
+import '../_helpers/link.js';
+import '../group/group.js';
+import '../_helpers/group.js';
+import '../global/listeners.js';
+import '../global/promise-with-timeout.js';
+import '../storage/storage.js';
+import '../storage/storage__local.js';
+import '../storage/storage__fallback.js';
+import 'deep-equal';
+import './request-builder.js';
+import 'simply-uuid';
+import './background-flow.js';
+
+const parser = new AuthResponseParser();
+const authResponse = parser.getAuthResponseFromURL();
+async function parseAndStoreResponse(clientId) {
+  const storage = new AuthStorage({
+    messagePrefix: `${clientId}-message-`,
+    stateKeyPrefix: `${clientId}-states-`,
+    tokenKey: `${clientId}-token`,
+    userKey: `${clientId}-user-`
+  });
+
+  if (!authResponse) {
+    return;
+  }
+
+  const {
+    state: stateId,
+    scope,
+    expiresIn,
+    accessToken
+  } = authResponse;
+  const newState = (await (stateId && this._storage.getState(stateId))) || {};
+  const scopes = scope ? scope.split(' ') : newState.scopes || [];
+  const effectiveExpiresIn = expiresIn ? parseInt(expiresIn, 10) : DEFAULT_EXPIRES_TIMEOUT;
+  const expires = TokenValidator._epoch() + effectiveExpiresIn;
+  await storage.saveToken({
+    accessToken,
+    scopes,
+    expires
+  });
+}
+
+export { parseAndStoreResponse as default };

package/dist/auth/request-builder.js

@@ -0,0 +1,75 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import uuid from 'simply-uuid';
+import { encodeURL } from '../global/url.js';
+
+class AuthRequestBuilder {
+  /**
+   * @param {{
+   *   authorization: string,
+   *   redirectUri: string?,
+   *   requestCredentials: string?,
+   *   clientId: string?,
+   *   scopes: string[]
+   * }} config
+   * @param {AuthStorage} storage
+   */
+  constructor(config, storage) {
+    this.config = config;
+    this.storage = storage;
+  }
+  /**
+   * @return {string} random string used for state
+   */
+
+
+  /**
+   * 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);
+  }
+
+}
+
+_defineProperty(AuthRequestBuilder, "_uuid", uuid.generate);
+
+export { AuthRequestBuilder as default };

package/dist/auth/response-parser.js

@@ -0,0 +1,117 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import ExtendableError from 'es6-error';
+import { parseQueryString } from '../global/url.js';
+
+/**
+ * @typedef {Object} AuthResponse
+ * @property {?string} accessToken
+ * @property {?string} state
+ * @property {?string} token_type
+ * @property {?string} expiresIn
+ * @property {?string} scope
+ * @property {?string} error
+ */
+
+class AuthResponseParser {
+  constructor() {
+    this._authResponse = this.readAuthResponseFromURL();
+  }
+
+  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);
+    } // If there is no token in the hash
+
+
+    if (!authResponse.accessToken) {
+      return null;
+    }
+
+    return authResponse;
+  }
+  /**
+   * 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;
+      }
+
+      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();
+  }
+
+}
+
+_defineProperty(AuthResponseParser, "AuthError", class AuthError extends 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;
+  }
+
+});
+
+export { AuthResponseParser as default };