@jetbrains/ring-ui-built 6.0.31 → 6.0.32

package/components/user-agreement/service.js

@@ -1,8 +1,3 @@
-import { b as _createClass, f as _classCallCheck, _ as _defineProperty, h as _asyncToGenerator, d as _objectSpread2, i as _regeneratorRuntime, j as _slicedToArray } from '../_helpers/_rollupPluginBabelHelpers.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/web.dom-collections.iterator.js';
 import React from 'react';
 import { createRoot } from 'react-dom/client';
 import ActualStorage from '../storage/storage.js';
@@ -14,24 +9,16 @@ import { ControlsHeightContext, getGlobalControlsHeight } from '../global/contro
 import UserAgreement from './user-agreement.js';
 import '../storage/storage__local.js';
 import '../storage/storage__fallback.js';
-import 'core-js/modules/es.array.concat.js';
-import 'core-js/modules/es.array.index-of.js';
-import 'core-js/modules/es.reflect.delete-property.js';
 import 'deep-equal';
-import 'core-js/modules/es.array.filter.js';
-import 'core-js/modules/es.array.map.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
 import '../global/get-uid.js';
-import 'core-js/modules/es.regexp.to-string.js';
 import '../alert/container.js';
 import 'react-dom';
 import 'classnames';
 import 'prop-types';
 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';
@@ -40,18 +27,9 @@ 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.map.js';
-import 'core-js/modules/es.weak-map.js';
 import '../loader-inline/loader-inline.js';
 import '../global/dom.js';
-import 'core-js/modules/es.object.assign.js';
-import 'core-js/modules/es.set.js';
-import 'core-js/modules/es.string.split.js';
-import 'core-js/modules/web.dom-collections.for-each.js';
 import '../button/button.js';
 import '@jetbrains/icons/chevron-10px';
 import '../_helpers/button__classes.js';
@@ -61,18 +39,11 @@ import '../popup/popup.js';
 import '../global/schedule-raf.js';
 import '../shortcuts/shortcuts.js';
 import '../shortcuts/core.js';
-import 'core-js/modules/es.array.find-index.js';
-import 'core-js/modules/es.array.includes.js';
-import 'core-js/modules/es.array.slice.js';
-import 'core-js/modules/es.array.splice.js';
-import 'core-js/modules/es.string.includes.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 '../dialog/dialog.js';
 import '../island/island.js';
@@ -88,400 +59,286 @@ import '../panel/panel.js';
 import '../i18n/i18n-context.js';
 import '../i18n/i18n.js';
 
-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 = {
+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 = {
   accepted: false,
   majorVersion: 0,
   minorVersion: 0
 };
-var DEFAULT_AGREEMENT = {
+const DEFAULT_AGREEMENT = {
   enabled: false,
   majorVersion: 0,
   minorVersion: 0,
   requiredForREST: false,
   content: ''
 };
-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, "reactRoot", createRoot(this.container));
-  _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) {
+class UserAgreementService {
+  config;
+  constructor(config) {
+    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;
+  }
+  _dialogPromise = null;
+  _alertPromise = null;
+  tabId = Math.random();
+  interval = ONE_HOUR;
+  container = document.createElement('div');
+  reactRoot = createRoot(this.container);
+  storage = new ActualStorage();
+  checkingPromise = null;
+  guest = false;
+  userAgreement = DEFAULT_AGREEMENT;
+  userConsent = DEFAULT_CONSENT;
+  intervalId;
+  startChecking = () => {
+    this.intervalId = window.setInterval(this.checkConsentAndShowDialog, this.interval);
+    window.addEventListener('storage', this.onStorageEvent);
+    this.checkConsentAndShowDialog();
+  };
+  stopChecking = () => {
+    clearInterval(this.intervalId);
+    window.removeEventListener('storage', this.onStorageEvent);
+    this.hideDialog();
+  };
+  onStorageEvent = 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) {
+      const {
+        tabId,
+        command
+      } = JSON.parse(event.newValue);
+      if (tabId !== this.tabId) {
         if (command === showMessage) {
-          _this.checkConsentAndShowDialog(true);
+          this.checkConsentAndShowDialog(true);
         } else if (command === hideMessage) {
-          _this.hideDialogAndAlert(true);
+          this.hideDialogAndAlert(true);
         }
       }
     }
-  });
-  _defineProperty(this, "_notifyAboutShowing", function () {
+  };
+  _notifyAboutShowing = () => {
     localStorage.setItem(storageKey, JSON.stringify({
       command: showMessage,
-      tabId: _this.tabId
+      tabId: this.tabId
     }));
-  });
-  _defineProperty(this, "_notifyAboutHiding", function () {
+  };
+  _notifyAboutHiding = () => {
     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();
-      }
-    }, _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();
-      }
-    }, _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);
+      tabId: this.tabId
     }));
-    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();
-      }
-    }, _callee4);
-  })));
-  _defineProperty(this, "alertKey", void 0);
-  _defineProperty(this, "showAlert", function (withoutNotifications) {
-    if (_this._alertPromise) {
-      return _this._alertPromise;
+  };
+  getUserAgreement = async () => {
+    this.userAgreement = (await this.config.getUserAgreement()) || DEFAULT_AGREEMENT;
+    return this.userAgreement;
+  };
+  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;
+  };
+  checkConsentAndShowDialog = async withoutNotifications => {
+    if (await this.checkConsent()) {
+      return this.hideDialogAndAlert(withoutNotifications);
+    } else {
+      return this.showDialogOrAlert(withoutNotifications);
+    }
+  };
+  checkConsent = async () => {
+    if (!this.checkingPromise) {
+      this.checkingPromise = Promise.all([this.getUserAgreement(), this.getUserConsent()]);
+    }
+    const [userAgreement, userConsent] = await this.checkingPromise;
+    this.checkingPromise = null;
+    const {
+      enabled,
+      majorVersion: actualVersion
+    } = userAgreement;
+    const {
+      accepted,
+      majorVersion: acceptedVersion
+    } = userConsent;
+    return !enabled || accepted && actualVersion === acceptedVersion;
+  };
+  alertKey;
+  showAlert = 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);
+    this._alertPromise = new Promise((resolve, reject) => {
+      const {
+        userAgreement,
+        reviewNow,
+        remindLater
+      } = this.config.translations || {};
+      const 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);
-        };
-      }();
-      var message = /*#__PURE__*/React.createElement(Group, null, /*#__PURE__*/React.createElement("span", null, userAgreement || 'User Agreement'), /*#__PURE__*/React.createElement(Link, {
+      const onReview = async () => {
+        await this.showDialog(true, false, {
+          onRemindLater: onRemind
+        });
+        this.hideAlert(withoutNotifications);
+        resolve();
+      };
+      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, {
+      this.alertKey = alertService.addAlert(message, Alert.Type.WARNING, 0, {
         closeable: false
       });
     });
     if (!withoutNotifications) {
-      _this._notifyAboutShowing();
+      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;
+    return this._alertPromise;
+  };
+  hideAlert = withoutNotifications => {
+    const {
+      onRemindLater
+    } = this.config;
+    alertService.remove(this.alertKey);
+    this.alertKey = null;
+    this._alertPromise = null;
     if (onRemindLater) {
       onRemindLater();
     }
     if (!withoutNotifications) {
-      _this._notifyAboutHiding();
+      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 content = _this.userAgreement.content;
-    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);
+  };
+  showDialog = (() => {
+    var _this = this;
+    return 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 {
+        content
+      } = _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();
           };
-        }();
-        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);
+          const onClose = _this.hideDialogAndAlert;
+          const props = {
+            children: content,
+            show,
+            onAccept,
+            onDecline,
+            onClose,
+            translations,
+            preview,
+            ...restOptions
           };
-        }();
-        var onClose = _this.hideDialogAndAlert;
-        var props = _objectSpread2({
-          children: content,
-          show,
-          onAccept,
-          onDecline,
-          onClose,
-          translations,
-          preview
-        }, restOptions);
-        _this.reactRoot.render( /*#__PURE__*/React.createElement(ControlsHeightContext.Provider, {
-          value: getGlobalControlsHeight()
-        }, /*#__PURE__*/React.createElement(UserAgreement, props)));
-        if (onDialogShow) {
-          onDialogShow();
+          _this.reactRoot.render( /*#__PURE__*/React.createElement(ControlsHeightContext.Provider, {
+            value: getGlobalControlsHeight()
+          }, /*#__PURE__*/React.createElement(UserAgreement, props)));
+          if (onDialogShow) {
+            onDialogShow();
+          }
+        });
+        if (!withoutNotifications) {
+          _this._notifyAboutShowing();
         }
-      });
-      if (!withoutNotifications) {
-        _this._notifyAboutShowing();
       }
-    }
-    return _this._dialogPromise;
-  });
-  _defineProperty(this, "hideDialog", function (withoutNotifications) {
-    var onDialogHide = _this.config.onDialogHide;
-    _this.reactRoot.render(null);
+      return _this._dialogPromise;
+    };
+  })();
+  hideDialog = withoutNotifications => {
+    const {
+      onDialogHide
+    } = this.config;
+    this.reactRoot.render(null);
     if (onDialogHide) {
       onDialogHide();
-      _this._dialogPromise = null;
+      this._dialogPromise = null;
       if (!withoutNotifications) {
-        _this._notifyAboutHiding();
+        this._notifyAboutHiding();
       }
     }
-  });
-  _defineProperty(this, "showDialogOrAlert", function (withoutNotifications, preview, restOptions) {
-    if (_this.guest && !_this.userAgreement.requiredForREST) {
-      return _this.showAlert(withoutNotifications);
+  };
+  showDialogOrAlert = (withoutNotifications, preview, restOptions) => {
+    if (this.guest && !this.userAgreement.requiredForREST) {
+      return this.showAlert(withoutNotifications);
     }
-    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,
-            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();
+    return this.showDialog(withoutNotifications, preview, restOptions);
+  };
+  hideDialogAndAlert = withoutNotifications => {
+    this.hideAlert(withoutNotifications);
+    this.hideDialog(withoutNotifications);
+  };
+  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();
+    }
+  };
+  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');
-  }
-  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 };