@jetbrains/ring-ui-built 6.0.5-beta.0

package/components/auth/background-flow.d.ts

@@ -0,0 +1,31 @@
+import AuthRequestBuilder from './request-builder';
+import AuthStorage from './storage';
+export declare const HUB_AUTH_PAGE_OPENED = "HUB_AUTH_PAGE_OPENED";
+export default class BackgroundFlow {
+    _requestBuilder: AuthRequestBuilder;
+    _storage: AuthStorage;
+    _timeout: number;
+    private _promise?;
+    constructor(requestBuilder: AuthRequestBuilder, storage: AuthStorage, timeout: number);
+    /**
+     * Creates a hidden iframe
+     * @return {HTMLIFrameElement}
+     * @private
+     */
+    private _createHiddenFrame;
+    /**
+     * Redirects the given iframe to the given URL
+     * @param {HTMLIFrameElement} iframe
+     * @param {string} url
+     * @private
+     */
+    _redirectFrame(iframe: HTMLIFrameElement, url: string): void;
+    /**
+     * 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.
+     */
+    private _load;
+    authorize(): Promise<string>;
+}

package/components/auth/background-flow.js

@@ -0,0 +1,146 @@
+import { d as _createClass, c 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/web.dom-collections.for-each.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import 'es6-error';
+import '../global/url.js';
+import 'core-js/modules/es.string.match.js';
+
+var HUB_AUTH_PAGE_OPENED = 'HUB_AUTH_PAGE_OPENED';
+var BackgroundFlow = /*#__PURE__*/function () {
+  function BackgroundFlow(requestBuilder, storage, timeout) {
+    _classCallCheck(this, BackgroundFlow);
+    _defineProperty(this, "_requestBuilder", void 0);
+    _defineProperty(this, "_storage", void 0);
+    _defineProperty(this, "_timeout", void 0);
+    _defineProperty(this, "_promise", void 0);
+    this._requestBuilder = requestBuilder;
+    this._storage = storage;
+    this._timeout = timeout;
+  }
+  /**
+   * Creates a hidden iframe
+   * @return {HTMLIFrameElement}
+   * @private
+   */
+  _createClass(BackgroundFlow, [{
+    key: "_createHiddenFrame",
+    value: function _createHiddenFrame() {
+      var 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
+     */
+  }, {
+    key: "_redirectFrame",
+    value: function _redirectFrame(iframe, url) {
+      iframe.src = "".concat(url, "&rnd=").concat(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.
+     */
+  }, {
+    key: "_load",
+    value: function () {
+      var _load2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        var _this = this;
+        var authRequest;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return this._requestBuilder.
+              // eslint-disable-next-line camelcase
+              prepareAuthRequest({
+                request_credentials: 'silent'
+              }, {
+                nonRedirect: true
+              });
+            case 2:
+              authRequest = _context.sent;
+              return _context.abrupt("return", new Promise(function (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);
+                var iframe = _this._createHiddenFrame();
+                var cleanRun;
+                var timeout = setTimeout(function () {
+                  reject(new Error('Failed to refresh authorization'));
+                  cleanUp();
+                }, _this._timeout);
+                var removeTokenListener = _this._storage.onTokenChange(function (token) {
+                  if (token) {
+                    cleanUp();
+                    resolve(token.accessToken);
+                  }
+                });
+                var removeStateListener = _this._storage.onStateChange(authRequest.stateId, function (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);
+              }));
+            case 4:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function _load() {
+        return _load2.apply(this, arguments);
+      }
+      return _load;
+    }()
+  }, {
+    key: "authorize",
+    value: function authorize() {
+      var _this2 = this;
+      if (this._promise) {
+        return this._promise;
+      }
+      var resetPromise = function resetPromise() {
+        _this2._promise = null;
+      };
+      this._promise = this._load();
+      this._promise.then(resetPromise, resetPromise);
+      return this._promise;
+    }
+  }]);
+  return BackgroundFlow;
+}();
+
+export { HUB_AUTH_PAGE_OPENED, BackgroundFlow as default };

package/components/auth/down-notification.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+export interface BackendDownTranslations {
+    backendIsNotAvailable: string;
+    checkAgain: string;
+    errorMessage: string;
+}
+export interface BackendDownMessageProps {
+    translations: BackendDownTranslations;
+    onCheckAgain: (e: React.MouseEvent) => void;
+}
+export interface OnBackendDownParams {
+    translations: BackendDownTranslations;
+    onCheckAgain: () => void;
+}
+export default function onBackendDown({ onCheckAgain, translations }: OnBackendDownParams): () => void;

package/components/auth/down-notification.js

@@ -0,0 +1,155 @@
+import { h as _asyncToGenerator, i as _regeneratorRuntime } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.object.to-string.js';
+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 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.array.concat.js';
+import 'react-dom/client';
+import '../global/get-uid.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import '../alert/container.js';
+import 'react-dom';
+import 'classnames';
+import 'core-js/modules/es.object.values.js';
+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__svg.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.string.starts-with.js';
+import '../global/memoize.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+import '../loader-inline/loader-inline.js';
+import '../global/data-tests.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.entries.js';
+import '../global/dom.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.set.js';
+import '../button/button.js';
+import '@jetbrains/icons/chevron-10px';
+import '../link/clickableLink.js';
+import '../global/controls-height.js';
+import '../_helpers/button__classes.js';
+import '../_helpers/theme.js';
+import '../popup/popup.target.js';
+import '../popup/popup.js';
+import '../global/schedule-raf.js';
+import '../shortcuts/shortcuts.js';
+import '../shortcuts/core.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.array.splice.js';
+import 'core-js/modules/es.string.match.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+import '../tab-trap/tab-trap.js';
+import '../popup/position.js';
+import 'core-js/modules/es.array.sort.js';
+import '../popup/popup.consts.js';
+import '../_helpers/link.js';
+
+var modules_c87dd562 = {"unit":"i__const_unit_0","light":"light_rui_2ac4","title":"title_rui_b890","error":"error_rui_b890"};
+
+var key = null;
+function renderAlert(message) {
+  var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Alert.Type.WARNING;
+  var existingAlert = alertService.showingAlerts.filter(function (alert) {
+    return 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) {
+  var translations = _ref.translations,
+    onCheckAgain = _ref.onCheckAgain;
+  var backendIsNotAvailable = translations.backendIsNotAvailable,
+    checkAgain = translations.checkAgain,
+    errorMessage = translations.errorMessage;
+  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) {
+  var onCheckAgain = _ref2.onCheckAgain,
+    translations = _ref2.translations;
+  function checkAgainWithoutClosing(_x) {
+    return _checkAgainWithoutClosing.apply(this, arguments);
+  }
+  function _checkAgainWithoutClosing() {
+    _checkAgainWithoutClosing = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(e) {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            // Alert has weird behaviour of handling clicks by "a" tags
+            e.stopPropagation();
+            _context.prev = 1;
+            renderAlert('Connecting...', Alert.Type.LOADING);
+            _context.next = 5;
+            return onCheckAgain();
+          case 5:
+            _context.next = 10;
+            break;
+          case 7:
+            _context.prev = 7;
+            _context.t0 = _context["catch"](1);
+            renderAlert( /*#__PURE__*/React.createElement(Message, {
+              translations: translations,
+              onCheckAgain: checkAgainWithoutClosing
+            }));
+          case 10:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[1, 7]]);
+    }));
+    return _checkAgainWithoutClosing.apply(this, arguments);
+  }
+  renderAlert( /*#__PURE__*/React.createElement(Message, {
+    translations: translations,
+    onCheckAgain: checkAgainWithoutClosing
+  }));
+  return function () {
+    return alertService.remove(key);
+  };
+}
+
+export { onBackendDown as default };

package/components/auth/iframe-flow.d.ts

@@ -0,0 +1,20 @@
+import { AuthTranslations, LoginFlow } from './auth__core';
+import AuthRequestBuilder from './request-builder';
+import AuthStorage from './storage';
+export default class IFrameFlow implements LoginFlow {
+    hideDialog: (() => void) | null;
+    private _requestBuilder;
+    private _storage;
+    private _translations;
+    reject?: (reason: unknown) => void;
+    private _promise?;
+    private _loginWindow?;
+    constructor(requestBuilder: AuthRequestBuilder, storage: AuthStorage, translations: AuthTranslations);
+    /**
+     * Initiates authorization in window
+     */
+    private _load;
+    _reset: () => void;
+    stop(): void;
+    authorize(): Promise<string>;
+}

package/components/auth/iframe-flow.js

@@ -0,0 +1,192 @@
+import { d as _createClass, c as _classCallCheck, _ as _defineProperty, h as _asyncToGenerator, i as _regeneratorRuntime } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.promise.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/client';
+import '../global/controls-height.js';
+import '../login-dialog/login-dialog.js';
+import 'core-js/modules/es.array.concat.js';
+import 'prop-types';
+import '../dialog/dialog.js';
+import 'react-dom';
+import 'classnames';
+import '@jetbrains/icons/close';
+import '../island/island.js';
+import '../global/data-tests.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.entries.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 'core-js/modules/es.regexp.to-string.js';
+import '../shortcuts/shortcuts.js';
+import 'core-js/modules/es.array.map.js';
+import '../shortcuts/core.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.array.splice.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.match.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+import '../tab-trap/tab-trap.js';
+import 'core-js/modules/es.array.filter.js';
+import '../global/dom.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.set.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import '../button/button.js';
+import '@jetbrains/icons/chevron-10px';
+import '../icon/icon.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon__svg.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.string.starts-with.js';
+import '../global/memoize.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/es.weak-map.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 './background-flow.js';
+import 'es6-error';
+import '../global/url.js';
+import '../_helpers/link.js';
+
+var IFrameFlow = /*#__PURE__*/function () {
+  function IFrameFlow(requestBuilder, storage, translations) {
+    var _this = this;
+    _classCallCheck(this, IFrameFlow);
+    _defineProperty(this, "hideDialog", null);
+    _defineProperty(this, "_requestBuilder", void 0);
+    _defineProperty(this, "_storage", void 0);
+    _defineProperty(this, "_translations", void 0);
+    _defineProperty(this, "reject", void 0);
+    _defineProperty(this, "_promise", void 0);
+    _defineProperty(this, "_loginWindow", void 0);
+    _defineProperty(this, "_reset", function () {
+      _this._promise = null;
+      _this.hideDialog = null;
+    });
+    this._requestBuilder = requestBuilder;
+    this._storage = storage;
+    this._translations = translations;
+    this._reset();
+  }
+  /**
+   * Initiates authorization in window
+   */
+  _createClass(IFrameFlow, [{
+    key: "_load",
+    value: function () {
+      var _load2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        var _this2 = this;
+        var authRequest, renderFallbackLink;
+        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: false
+              });
+            case 2:
+              authRequest = _context.sent;
+              renderFallbackLink = function renderFallbackLink() {
+                return /*#__PURE__*/React.createElement(Link, {
+                  href: authRequest.url,
+                  target: "_self"
+                }, _this2._translations.nothingHappensLink);
+              };
+              return _context.abrupt("return", new Promise(function (resolve, reject) {
+                _this2.hideDialog = showAuthDialog({
+                  url: authRequest.url,
+                  loader: true,
+                  onCancel: function onCancel() {
+                    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                    cleanUp();
+                    _this2.stop();
+                  },
+                  renderFallbackLink
+                });
+                _this2.reject = reject;
+                var removeTokenListener = _this2._storage.onTokenChange(function (token) {
+                  if (token) {
+                    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                    cleanUp();
+                    resolve(token.accessToken);
+                  }
+                });
+                var removeStateListener = _this2._storage.onStateChange(authRequest.stateId, function (state) {
+                  if (state && state.error) {
+                    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                    cleanUp();
+                    reject(new AuthResponseParser.AuthError(state));
+                  }
+                });
+                var cleanUp = function cleanUp() {
+                  var _this2$hideDialog;
+                  (_this2$hideDialog = _this2.hideDialog) === null || _this2$hideDialog === void 0 ? void 0 : _this2$hideDialog.call(_this2);
+                  removeStateListener();
+                  removeTokenListener();
+                };
+              }));
+            case 5:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function _load() {
+        return _load2.apply(this, arguments);
+      }
+      return _load;
+    }()
+  }, {
+    key: "stop",
+    value: function stop() {
+      if (this.hideDialog) {
+        this.hideDialog();
+      }
+      if (this.reject) {
+        this.reject('Login form closed');
+      }
+      this._reset();
+    }
+  }, {
+    key: "authorize",
+    value: function authorize() {
+      if (this._promise != null && this._loginWindow != null && !this._loginWindow.closed) {
+        return this._promise;
+      }
+      this._promise = this._load();
+      this._promise.then(this._reset, this._reset);
+      return this._promise;
+    }
+  }]);
+  return IFrameFlow;
+}();
+
+export { IFrameFlow as default };

package/components/auth/request-builder.d.ts

@@ -0,0 +1,47 @@
+import uuid from 'simply-uuid';
+import AuthStorage, { AuthState } from './storage';
+export interface AuthRequestBuilderConfig {
+    authorization: string;
+    redirectUri?: string | null | undefined;
+    requestCredentials?: string | null | undefined;
+    clientId?: string | null | undefined;
+    scopes: readonly string[];
+    redirect?: boolean | null | undefined;
+}
+export default class AuthRequestBuilder {
+    config: AuthRequestBuilderConfig;
+    storage: AuthStorage | undefined;
+    /**
+     * @param {{
+     *   authorization: string,
+     *   redirectUri: string?,
+     *   requestCredentials: string?,
+     *   clientId: string?,
+     *   scopes: string[]
+     * }} config
+     * @param {AuthStorage} storage
+     */
+    constructor(config: AuthRequestBuilderConfig, storage?: AuthStorage);
+    /**
+     * @return {string} random string used for state
+     */
+    static _uuid: typeof 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
+     */
+    prepareAuthRequest(extraParams?: Record<string, unknown> | null | undefined, extraState?: Partial<AuthState>): Promise<{
+        url: string;
+        stateId: string;
+    }>;
+    /**
+     * @param {string} id
+     * @param {StoredState} storedState
+     * @return {Promise}
+     * @private
+     */
+    _saveState(id: string, storedState: AuthState): Promise<void> | undefined;
+}