@jetbrains/ring-ui 5.0.156 → 5.0.157

package/dist/auth/background-flow.js

@@ -1,14 +1,26 @@
+import { _ as _createClass, b as _classCallCheck, c as _defineProperty, e as _asyncToGenerator, f 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.object.keys.js';
+import 'core-js/modules/es.array.index-of.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';
 
-const HUB_AUTH_PAGE_OPENED = 'HUB_AUTH_PAGE_OPENED';
-class BackgroundFlow {
-  _requestBuilder;
-  _storage;
-  _timeout;
-  _promise;
-  constructor(requestBuilder, storage, timeout) {
+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;
@@ -18,89 +30,119 @@ class BackgroundFlow {
    * @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();
-        }
+  _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);
       }
-      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);
+      return _load;
+    }()
+  }, {
+    key: "authorize",
+    value: function authorize() {
+      var _this2 = this;
+      if (this._promise) {
+        return this._promise;
       }
-      this._redirectFrame(iframe, authRequest.url);
-    });
-  }
-  authorize() {
-    if (this._promise) {
+      var resetPromise = function resetPromise() {
+        _this2._promise = null;
+      };
+      this._promise = this._load();
+      this._promise.then(resetPromise, resetPromise);
       return this._promise;
     }
-    const resetPromise = () => {
-      this._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/dist/auth/down-notification.js

@@ -1,15 +1,25 @@
+import { e as _asyncToGenerator, f 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 '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.array.concat.js';
 import '../global/react-render-adapter.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.string.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
 import 'react-dom';
 import '../global/get-uid.js';
+import 'core-js/modules/es.regexp.to-string.js';
 import '../alert/container.js';
 import 'classnames';
+import 'core-js/modules/es.object.values.js';
 import '@jetbrains/icons/exception';
 import '@jetbrains/icons/checkmark';
 import '@jetbrains/icons/warning';
@@ -19,11 +29,22 @@ import 'util-deprecate';
 import '../icon/icon__constants.js';
 import '../_helpers/icon.js';
 import '../icon/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.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 '../_helpers/loader-inline.js';
 import '../global/dom.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.object.keys.js';
+import 'core-js/modules/es.set.js';
 import '../button/button.js';
 import '@jetbrains/icons/chevron-10px';
 import '../link/clickableLink.js';
@@ -35,21 +56,30 @@ 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 'core-js/modules/es.array.find-index.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';
 import '../_helpers/group.js';
 
 var modules_c87dd562 = {"unit":"i__const_unit_0","light":"light_rui_2ac4","title":"title_rui_b890","error":"error_rui_b890"};
 
-let key = null;
+var 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];
+  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
@@ -61,15 +91,11 @@ function renderAlert(message) {
   }
 }
 function Message(_ref) {
-  let {
-    translations,
-    onCheckAgain
-  } = _ref;
-  const {
-    backendIsNotAvailable,
-    checkAgain,
-    errorMessage
-  } = translations;
+  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", {
@@ -90,28 +116,47 @@ Message.propTypes = {
   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
-      }));
-    }
+  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 () => alertService.remove(key);
+  return function () {
+    return alertService.remove(key);
+  };
 }
 
 export { onBackendDown as default };