@jetbrains/ring-ui 5.1.1 → 6.0.1-beta.0

package/dist/user-agreement/service.js

@@ -1,4 +1,10 @@
-import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { d as _createClass, c as _classCallCheck, _ as _defineProperty, h as _asyncToGenerator, g as _objectSpread2, i as _regeneratorRuntime, j as _slicedToArray } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.object.keys.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.promise.js';
+import 'core-js/modules/es.string.iterator.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
 import React from 'react';
 import { render, unmountComponentAtNode } from '../global/react-render-adapter.js';
 import ActualStorage from '../storage/storage.js';
@@ -6,12 +12,31 @@ import alertService from '../alert-service/alert-service.js';
 import Link from '../link/link.js';
 import Alert from '../alert/alert.js';
 import Group from '../group/group.js';
+import { ControlsHeightContext, getGlobalControlsHeight } from '../global/controls-height.js';
 import UserAgreement from './user-agreement.js';
+import 'core-js/modules/es.weak-map.js';
 import 'react-dom';
 import '../storage/storage__local.js';
+import '../storage/storage__fallback.js';
+import 'core-js/modules/es.reflect.delete-property.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.array.index-of.js';
+import 'deep-equal';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.array.filter.js';
 import '../global/get-uid.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import '../alert/container.js';
 import 'classnames';
 import 'prop-types';
+import '../global/memoize.js';
+import 'core-js/modules/es.map.js';
+import '../global/data-tests.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.entries.js';
+import '../link/clickableLink.js';
+import '../_helpers/link.js';
+import 'core-js/modules/es.object.values.js';
 import '@jetbrains/icons/exception';
 import '@jetbrains/icons/checkmark';
 import '@jetbrains/icons/warning';
@@ -21,16 +46,18 @@ import 'util-deprecate';
 import '../icon/icon__constants.js';
 import '../_helpers/icon.js';
 import '../icon/icon__svg.js';
-import '../global/memoize.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 '../loader-inline/loader-inline.js';
-import '../global/data-tests.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.set.js';
 import '../button/button.js';
-import 'focus-visible';
 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';
@@ -38,16 +65,19 @@ 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 '../alert/container.js';
-import '../storage/storage__fallback.js';
-import 'deep-equal';
-import '../_helpers/link.js';
 import '../_helpers/group.js';
 import '../dialog/dialog.js';
 import '../island/island.js';
@@ -66,289 +96,411 @@ import 'react-markdown';
 import 'remark-breaks';
 import 'remark-gfm';
 import '../global/normalize-indent.js';
+import 'core-js/modules/es.array.reverse.js';
 import '../global/trivial-template-tag.js';
 import '../markdown/code.js';
+import 'core-js/modules/es.array.find.js';
 import '../code/code.js';
 import 'highlight.js/lib/core';
 import '../markdown/link.js';
 import '../markdown/heading.js';
 import '../heading/heading.js';
+import '../i18n/i18n-context.js';
+import '../i18n/i18n.js';
 
-const GUEST_SESSION_KEY = 'end-user-agreement-consent';
-const ONE_HOUR = 60 * 60 * 1000; // eslint-disable-line @typescript-eslint/no-magic-numbers
-const storageKey = 'userAgreementKey';
-const showMessage = 'userAgreementShow';
-const hideMessage = 'userAgreementHide';
-const DEFAULT_CONSENT = {
+var GUEST_SESSION_KEY = 'end-user-agreement-consent';
+var ONE_HOUR = 60 * 60 * 1000; // eslint-disable-line @typescript-eslint/no-magic-numbers
+var storageKey = 'userAgreementKey';
+var showMessage = 'userAgreementShow';
+var hideMessage = 'userAgreementHide';
+var DEFAULT_CONSENT = {
   accepted: false,
   majorVersion: 0,
   minorVersion: 0
 };
-const DEFAULT_AGREEMENT = {
+var DEFAULT_AGREEMENT = {
   enabled: false,
   majorVersion: 0,
   minorVersion: 0,
   requiredForREST: false,
   text: ''
 };
-class UserAgreementService {
-  constructor(config) {
-    var _this = this;
-    _defineProperty(this, "config", void 0);
-    _defineProperty(this, "_dialogPromise", null);
-    _defineProperty(this, "_alertPromise", null);
-    _defineProperty(this, "tabId", Math.random());
-    _defineProperty(this, "interval", ONE_HOUR);
-    _defineProperty(this, "container", document.createElement('div'));
-    _defineProperty(this, "storage", new ActualStorage());
-    _defineProperty(this, "checkingPromise", null);
-    _defineProperty(this, "guest", false);
-    _defineProperty(this, "userAgreement", DEFAULT_AGREEMENT);
-    _defineProperty(this, "userConsent", DEFAULT_CONSENT);
-    _defineProperty(this, "intervalId", void 0);
-    _defineProperty(this, "startChecking", () => {
-      this.intervalId = window.setInterval(this.checkConsentAndShowDialog, this.interval);
-      window.addEventListener('storage', this.onStorageEvent);
-      this.checkConsentAndShowDialog();
-    });
-    _defineProperty(this, "stopChecking", () => {
-      clearInterval(this.intervalId);
-      window.removeEventListener('storage', this.onStorageEvent);
-      this.hideDialog();
-    });
-    _defineProperty(this, "onStorageEvent", event => {
-      if (event.key === storageKey && event.newValue != null) {
-        const {
-          tabId,
-          command
-        } = JSON.parse(event.newValue);
-        if (tabId !== this.tabId) {
-          if (command === showMessage) {
-            this.checkConsentAndShowDialog(true);
-          } else if (command === hideMessage) {
-            this.hideDialogAndAlert(true);
-          }
+var UserAgreementService = /*#__PURE__*/_createClass(function UserAgreementService(config) {
+  var _this = this;
+  _classCallCheck(this, UserAgreementService);
+  _defineProperty(this, "config", void 0);
+  _defineProperty(this, "_dialogPromise", null);
+  _defineProperty(this, "_alertPromise", null);
+  _defineProperty(this, "tabId", Math.random());
+  _defineProperty(this, "interval", ONE_HOUR);
+  _defineProperty(this, "container", document.createElement('div'));
+  _defineProperty(this, "storage", new ActualStorage());
+  _defineProperty(this, "checkingPromise", null);
+  _defineProperty(this, "guest", false);
+  _defineProperty(this, "userAgreement", DEFAULT_AGREEMENT);
+  _defineProperty(this, "userConsent", DEFAULT_CONSENT);
+  _defineProperty(this, "intervalId", void 0);
+  _defineProperty(this, "startChecking", function () {
+    _this.intervalId = window.setInterval(_this.checkConsentAndShowDialog, _this.interval);
+    window.addEventListener('storage', _this.onStorageEvent);
+    _this.checkConsentAndShowDialog();
+  });
+  _defineProperty(this, "stopChecking", function () {
+    clearInterval(_this.intervalId);
+    window.removeEventListener('storage', _this.onStorageEvent);
+    _this.hideDialog();
+  });
+  _defineProperty(this, "onStorageEvent", function (event) {
+    if (event.key === storageKey && event.newValue != null) {
+      var _JSON$parse = JSON.parse(event.newValue),
+        tabId = _JSON$parse.tabId,
+        command = _JSON$parse.command;
+      if (tabId !== _this.tabId) {
+        if (command === showMessage) {
+          _this.checkConsentAndShowDialog(true);
+        } else if (command === hideMessage) {
+          _this.hideDialogAndAlert(true);
         }
       }
-    });
-    _defineProperty(this, "_notifyAboutShowing", () => {
-      localStorage.setItem(storageKey, JSON.stringify({
-        command: showMessage,
-        tabId: this.tabId
-      }));
-    });
-    _defineProperty(this, "_notifyAboutHiding", () => {
-      localStorage.setItem(storageKey, JSON.stringify({
-        command: hideMessage,
-        tabId: this.tabId
-      }));
-    });
-    _defineProperty(this, "getUserAgreement", async () => {
-      this.userAgreement = (await this.config.getUserAgreement()) || DEFAULT_AGREEMENT;
-      return this.userAgreement;
-    });
-    _defineProperty(this, "getUserConsent", async () => {
-      const {
-        guest,
-        endUserAgreementConsent
-      } = await this.config.getUserConsent();
-      this.guest = guest;
-      if (guest) {
-        this.userConsent = (await this.storage.get(GUEST_SESSION_KEY)) || this.userConsent;
-      } else {
-        this.userConsent = endUserAgreementConsent || this.userConsent;
-      }
-      return this.userConsent;
-    });
-    _defineProperty(this, "checkConsentAndShowDialog", async withoutNotifications => {
-      if (await this.checkConsent()) {
-        return this.hideDialogAndAlert(withoutNotifications);
-      } else {
-        return this.showDialogOrAlert(withoutNotifications);
+    }
+  });
+  _defineProperty(this, "_notifyAboutShowing", function () {
+    localStorage.setItem(storageKey, JSON.stringify({
+      command: showMessage,
+      tabId: _this.tabId
+    }));
+  });
+  _defineProperty(this, "_notifyAboutHiding", function () {
+    localStorage.setItem(storageKey, JSON.stringify({
+      command: hideMessage,
+      tabId: _this.tabId
+    }));
+  });
+  _defineProperty(this, "getUserAgreement", /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return _this.config.getUserAgreement();
+        case 2:
+          _context.t0 = _context.sent;
+          if (_context.t0) {
+            _context.next = 5;
+            break;
+          }
+          _context.t0 = DEFAULT_AGREEMENT;
+        case 5:
+          _this.userAgreement = _context.t0;
+          return _context.abrupt("return", _this.userAgreement);
+        case 7:
+        case "end":
+          return _context.stop();
       }
-    });
-    _defineProperty(this, "checkConsent", async () => {
-      if (!this.checkingPromise) {
-        this.checkingPromise = Promise.all([this.getUserAgreement(), this.getUserConsent()]);
+    }, _callee);
+  })));
+  _defineProperty(this, "getUserConsent", /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+    var _yield$_this$config$g, guest, endUserAgreementConsent;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.next = 2;
+          return _this.config.getUserConsent();
+        case 2:
+          _yield$_this$config$g = _context2.sent;
+          guest = _yield$_this$config$g.guest;
+          endUserAgreementConsent = _yield$_this$config$g.endUserAgreementConsent;
+          _this.guest = guest;
+          if (!guest) {
+            _context2.next = 15;
+            break;
+          }
+          _context2.next = 9;
+          return _this.storage.get(GUEST_SESSION_KEY);
+        case 9:
+          _context2.t0 = _context2.sent;
+          if (_context2.t0) {
+            _context2.next = 12;
+            break;
+          }
+          _context2.t0 = _this.userConsent;
+        case 12:
+          _this.userConsent = _context2.t0;
+          _context2.next = 16;
+          break;
+        case 15:
+          _this.userConsent = endUserAgreementConsent || _this.userConsent;
+        case 16:
+          return _context2.abrupt("return", _this.userConsent);
+        case 17:
+        case "end":
+          return _context2.stop();
       }
-      const [userAgreement, userConsent] = await this.checkingPromise;
-      this.checkingPromise = null;
-      const {
-        enabled,
-        majorVersion: actualVersion
-      } = userAgreement;
-      const {
-        accepted,
-        majorVersion: acceptedVersion
-      } = userConsent;
-      return !enabled || accepted && actualVersion === acceptedVersion;
-    });
-    _defineProperty(this, "alertKey", void 0);
-    _defineProperty(this, "showAlert", withoutNotifications => {
-      if (this._alertPromise) {
-        return this._alertPromise;
+    }, _callee2);
+  })));
+  _defineProperty(this, "checkConsentAndShowDialog", /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(withoutNotifications) {
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.next = 2;
+            return _this.checkConsent();
+          case 2:
+            if (!_context3.sent) {
+              _context3.next = 6;
+              break;
+            }
+            return _context3.abrupt("return", _this.hideDialogAndAlert(withoutNotifications));
+          case 6:
+            return _context3.abrupt("return", _this.showDialogOrAlert(withoutNotifications));
+          case 7:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }));
+    return function (_x) {
+      return _ref3.apply(this, arguments);
+    };
+  }());
+  _defineProperty(this, "checkConsent", /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+    var _yield$_this$checking, _yield$_this$checking2, userAgreement, userConsent, enabled, actualVersion, accepted, acceptedVersion;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          if (!_this.checkingPromise) {
+            _this.checkingPromise = Promise.all([_this.getUserAgreement(), _this.getUserConsent()]);
+          }
+          _context4.next = 3;
+          return _this.checkingPromise;
+        case 3:
+          _yield$_this$checking = _context4.sent;
+          _yield$_this$checking2 = _slicedToArray(_yield$_this$checking, 2);
+          userAgreement = _yield$_this$checking2[0];
+          userConsent = _yield$_this$checking2[1];
+          _this.checkingPromise = null;
+          enabled = userAgreement.enabled, actualVersion = userAgreement.majorVersion;
+          accepted = userConsent.accepted, acceptedVersion = userConsent.majorVersion;
+          return _context4.abrupt("return", !enabled || accepted && actualVersion === acceptedVersion);
+        case 11:
+        case "end":
+          return _context4.stop();
       }
-      this._alertPromise = new Promise((resolve, reject) => {
-        const {
-          userAgreement,
-          reviewNow,
-          remindLater
-        } = this.config.translations || {};
-        const onRemind = () => {
-          this.hideDialogAndAlert(withoutNotifications);
-          reject('Postponed');
-        };
-        const onReview = async () => {
-          await this.showDialog(true, false, {
-            onRemindLater: onRemind
-          });
-          this.hideAlert(withoutNotifications);
-          resolve();
+    }, _callee4);
+  })));
+  _defineProperty(this, "alertKey", void 0);
+  _defineProperty(this, "showAlert", function (withoutNotifications) {
+    if (_this._alertPromise) {
+      return _this._alertPromise;
+    }
+    _this._alertPromise = new Promise(function (resolve, reject) {
+      var _ref5 = _this.config.translations || {},
+        userAgreement = _ref5.userAgreement,
+        reviewNow = _ref5.reviewNow,
+        remindLater = _ref5.remindLater;
+      var onRemind = function onRemind() {
+        _this.hideDialogAndAlert(withoutNotifications);
+        reject('Postponed');
+      };
+      var onReview = /*#__PURE__*/function () {
+        var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
+          return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+            while (1) switch (_context5.prev = _context5.next) {
+              case 0:
+                _context5.next = 2;
+                return _this.showDialog(true, false, {
+                  onRemindLater: onRemind
+                });
+              case 2:
+                _this.hideAlert(withoutNotifications);
+                resolve();
+              case 4:
+              case "end":
+                return _context5.stop();
+            }
+          }, _callee5);
+        }));
+        return function onReview() {
+          return _ref6.apply(this, arguments);
         };
-        const message = /*#__PURE__*/React.createElement(Group, null, /*#__PURE__*/React.createElement("span", null, userAgreement || 'User Agreement'), /*#__PURE__*/React.createElement(Link, {
-          onClick: onReview,
-          "data-test": "review"
-        }, reviewNow || 'Review now'), /*#__PURE__*/React.createElement(Link, {
-          onClick: onRemind,
-          "data-test": "later"
-        }, remindLater || 'Remind me later'));
-        this.alertKey = alertService.addAlert(message, Alert.Type.WARNING, 0, {
-          closeable: false
-        });
+      }();
+      var message = /*#__PURE__*/React.createElement(Group, null, /*#__PURE__*/React.createElement("span", null, userAgreement || 'User Agreement'), /*#__PURE__*/React.createElement(Link, {
+        onClick: onReview,
+        "data-test": "review"
+      }, reviewNow || 'Review now'), /*#__PURE__*/React.createElement(Link, {
+        onClick: onRemind,
+        "data-test": "later"
+      }, remindLater || 'Remind me later'));
+      _this.alertKey = alertService.addAlert(message, Alert.Type.WARNING, 0, {
+        closeable: false
       });
-      if (!withoutNotifications) {
-        this._notifyAboutShowing();
-      }
-      return this._alertPromise;
-    });
-    _defineProperty(this, "hideAlert", withoutNotifications => {
-      const {
-        onRemindLater
-      } = this.config;
-      alertService.remove(this.alertKey);
-      this.alertKey = null;
-      this._alertPromise = null;
-      if (onRemindLater) {
-        onRemindLater();
-      }
-      if (!withoutNotifications) {
-        this._notifyAboutHiding();
-      }
     });
-    _defineProperty(this, "showDialog", function (withoutNotifications) {
-      let preview = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      let restOptions = arguments.length > 2 ? arguments[2] : undefined;
-      const {
-        translations,
-        onDialogShow
-      } = _this.config;
-      const {
-        text
-      } = _this.userAgreement;
-      const show = true;
-      if (!_this._dialogPromise) {
-        _this._dialogPromise = new Promise((resolve, reject) => {
-          const onAccept = async () => {
-            await _this.onAccept();
-            resolve();
-          };
-          const onDecline = async () => {
-            await _this.onDecline();
-            reject();
+    if (!withoutNotifications) {
+      _this._notifyAboutShowing();
+    }
+    return _this._alertPromise;
+  });
+  _defineProperty(this, "hideAlert", function (withoutNotifications) {
+    var onRemindLater = _this.config.onRemindLater;
+    alertService.remove(_this.alertKey);
+    _this.alertKey = null;
+    _this._alertPromise = null;
+    if (onRemindLater) {
+      onRemindLater();
+    }
+    if (!withoutNotifications) {
+      _this._notifyAboutHiding();
+    }
+  });
+  _defineProperty(this, "showDialog", function (withoutNotifications) {
+    var preview = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var restOptions = arguments.length > 2 ? arguments[2] : undefined;
+    var _this$config = _this.config,
+      translations = _this$config.translations,
+      onDialogShow = _this$config.onDialogShow;
+    var text = _this.userAgreement.text;
+    var show = true;
+    if (!_this._dialogPromise) {
+      _this._dialogPromise = new Promise(function (resolve, reject) {
+        var onAccept = /*#__PURE__*/function () {
+          var _ref7 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
+            return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+              while (1) switch (_context6.prev = _context6.next) {
+                case 0:
+                  _context6.next = 2;
+                  return _this.onAccept();
+                case 2:
+                  resolve();
+                case 3:
+                case "end":
+                  return _context6.stop();
+              }
+            }, _callee6);
+          }));
+          return function onAccept() {
+            return _ref7.apply(this, arguments);
           };
-          const onClose = _this.hideDialogAndAlert;
-          const props = {
-            text,
-            show,
-            onAccept,
-            onDecline,
-            onClose,
-            translations,
-            preview,
-            ...restOptions
+        }();
+        var onDecline = /*#__PURE__*/function () {
+          var _ref8 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
+            return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+              while (1) switch (_context7.prev = _context7.next) {
+                case 0:
+                  _context7.next = 2;
+                  return _this.onDecline();
+                case 2:
+                  reject();
+                case 3:
+                case "end":
+                  return _context7.stop();
+              }
+            }, _callee7);
+          }));
+          return function onDecline() {
+            return _ref8.apply(this, arguments);
           };
-          render( /*#__PURE__*/React.createElement(UserAgreement, props), _this.container);
-          if (onDialogShow) {
-            onDialogShow();
-          }
-        });
-        if (!withoutNotifications) {
-          _this._notifyAboutShowing();
-        }
-      }
-      return _this._dialogPromise;
-    });
-    _defineProperty(this, "hideDialog", withoutNotifications => {
-      const {
-        onDialogHide
-      } = this.config;
-      unmountComponentAtNode(this.container);
-      if (onDialogHide) {
-        onDialogHide();
-        this._dialogPromise = null;
-        if (!withoutNotifications) {
-          this._notifyAboutHiding();
+        }();
+        var onClose = _this.hideDialogAndAlert;
+        var props = _objectSpread2({
+          text: text,
+          show: show,
+          onAccept: onAccept,
+          onDecline: onDecline,
+          onClose: onClose,
+          translations: translations,
+          preview: preview
+        }, restOptions);
+        render( /*#__PURE__*/React.createElement(ControlsHeightContext.Provider, {
+          value: getGlobalControlsHeight()
+        }, /*#__PURE__*/React.createElement(UserAgreement, props)), _this.container);
+        if (onDialogShow) {
+          onDialogShow();
         }
+      });
+      if (!withoutNotifications) {
+        _this._notifyAboutShowing();
       }
-    });
-    _defineProperty(this, "showDialogOrAlert", (withoutNotifications, preview, restOptions) => {
-      if (this.guest && !this.userAgreement.requiredForREST) {
-        return this.showAlert(withoutNotifications);
-      }
-      return this.showDialog(withoutNotifications, preview, restOptions);
-    });
-    _defineProperty(this, "hideDialogAndAlert", withoutNotifications => {
-      this.hideAlert(withoutNotifications);
-      this.hideDialog(withoutNotifications);
-    });
-    _defineProperty(this, "onAccept", async () => {
-      const {
-        setUserConsent,
-        onAccept
-      } = this.config;
-      if (this.guest) {
-        const {
-          majorVersion,
-          minorVersion
-        } = this.userAgreement;
-        this.userConsent = {
-          majorVersion,
-          minorVersion,
-          accepted: true
-        };
-        await this.storage.set(GUEST_SESSION_KEY, this.userConsent);
-      } else {
-        this.userConsent = await setUserConsent();
-      }
-      this.hideDialog();
-      if (onAccept) {
-        onAccept();
-      }
-    });
-    _defineProperty(this, "onDecline", () => {
-      const {
-        onDecline
-      } = this.config;
-      this.hideDialog();
-      if (onDecline) {
-        onDecline();
-      }
-    });
-    if (!config) {
-      throw new Error('Please pass a config to UserAgreementService');
     }
-    if (!config.getUserAgreement) {
-      throw new Error('Please pass a "getUserAgreement" option to UserAgreementService');
+    return _this._dialogPromise;
+  });
+  _defineProperty(this, "hideDialog", function (withoutNotifications) {
+    var onDialogHide = _this.config.onDialogHide;
+    unmountComponentAtNode(_this.container);
+    if (onDialogHide) {
+      onDialogHide();
+      _this._dialogPromise = null;
+      if (!withoutNotifications) {
+        _this._notifyAboutHiding();
+      }
     }
-    if (!config.getUserConsent) {
-      throw new Error('Please pass a "getUserConsent" option to UserAgreementService');
+  });
+  _defineProperty(this, "showDialogOrAlert", function (withoutNotifications, preview, restOptions) {
+    if (_this.guest && !_this.userAgreement.requiredForREST) {
+      return _this.showAlert(withoutNotifications);
     }
-    if (!config.setUserConsent) {
-      throw new Error('Please pass a "setUserConsent" option to UserAgreementService');
+    return _this.showDialog(withoutNotifications, preview, restOptions);
+  });
+  _defineProperty(this, "hideDialogAndAlert", function (withoutNotifications) {
+    _this.hideAlert(withoutNotifications);
+    _this.hideDialog(withoutNotifications);
+  });
+  _defineProperty(this, "onAccept", /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8() {
+    var _this$config2, setUserConsent, onAccept, _this$userAgreement, majorVersion, minorVersion;
+    return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          _this$config2 = _this.config, setUserConsent = _this$config2.setUserConsent, onAccept = _this$config2.onAccept;
+          if (!_this.guest) {
+            _context8.next = 8;
+            break;
+          }
+          _this$userAgreement = _this.userAgreement, majorVersion = _this$userAgreement.majorVersion, minorVersion = _this$userAgreement.minorVersion;
+          _this.userConsent = {
+            majorVersion: majorVersion,
+            minorVersion: minorVersion,
+            accepted: true
+          };
+          _context8.next = 6;
+          return _this.storage.set(GUEST_SESSION_KEY, _this.userConsent);
+        case 6:
+          _context8.next = 11;
+          break;
+        case 8:
+          _context8.next = 10;
+          return setUserConsent();
+        case 10:
+          _this.userConsent = _context8.sent;
+        case 11:
+          _this.hideDialog();
+          if (onAccept) {
+            onAccept();
+          }
+        case 13:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  })));
+  _defineProperty(this, "onDecline", function () {
+    var onDecline = _this.config.onDecline;
+    _this.hideDialog();
+    if (onDecline) {
+      onDecline();
     }
-    this.config = config;
-    this.interval = config.interval || this.interval;
+  });
+  if (!config) {
+    throw new Error('Please pass a config to UserAgreementService');
+  }
+  if (!config.getUserAgreement) {
+    throw new Error('Please pass a "getUserAgreement" option to UserAgreementService');
+  }
+  if (!config.getUserConsent) {
+    throw new Error('Please pass a "getUserConsent" option to UserAgreementService');
+  }
+  if (!config.setUserConsent) {
+    throw new Error('Please pass a "setUserConsent" option to UserAgreementService');
   }
-}
+  this.config = config;
+  this.interval = config.interval || this.interval;
+});
 
 export { UserAgreementService as default, hideMessage, showMessage };