@jetbrains/ring-ui-built 6.0.32 → 6.0.33

package/components/user-agreement/service.js

@@ -1,3 +1,8 @@
+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';
@@ -9,16 +14,24 @@ 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 '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.array.map.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';
@@ -27,9 +40,18 @@ 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';
@@ -39,11 +61,18 @@ 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';
@@ -59,286 +88,400 @@ import '../panel/panel.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,
   content: ''
 };
-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 => {
+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) {
     if (event.key === storageKey && event.newValue != null) {
-      const {
-        tabId,
-        command
-      } = JSON.parse(event.newValue);
-      if (tabId !== this.tabId) {
+      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);
+          _this.checkConsentAndShowDialog(true);
         } else if (command === hideMessage) {
-          this.hideDialogAndAlert(true);
+          _this.hideDialogAndAlert(true);
         }
       }
     }
-  };
-  _notifyAboutShowing = () => {
+  });
+  _defineProperty(this, "_notifyAboutShowing", function () {
     localStorage.setItem(storageKey, JSON.stringify({
       command: showMessage,
-      tabId: this.tabId
+      tabId: _this.tabId
     }));
-  };
-  _notifyAboutHiding = () => {
+  });
+  _defineProperty(this, "_notifyAboutHiding", function () {
     localStorage.setItem(storageKey, JSON.stringify({
       command: hideMessage,
-      tabId: this.tabId
+      tabId: _this.tabId
     }));
-  };
-  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;
+  });
+  _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);
+    }));
+    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;
     }
-    this._alertPromise = new Promise((resolve, reject) => {
-      const {
-        userAgreement,
-        reviewNow,
-        remindLater
-      } = this.config.translations || {};
-      const onRemind = () => {
-        this.hideDialogAndAlert(withoutNotifications);
+    _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');
       };
-      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, {
+      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, {
         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;
-  };
-  hideAlert = withoutNotifications => {
-    const {
-      onRemindLater
-    } = this.config;
-    alertService.remove(this.alertKey);
-    this.alertKey = null;
-    this._alertPromise = null;
+    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();
+      _this._notifyAboutHiding();
     }
-  };
-  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();
+  });
+  _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);
           };
-          const onClose = _this.hideDialogAndAlert;
-          const props = {
-            children: content,
-            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);
           };
-          _this.reactRoot.render( /*#__PURE__*/React.createElement(ControlsHeightContext.Provider, {
-            value: getGlobalControlsHeight()
-          }, /*#__PURE__*/React.createElement(UserAgreement, props)));
-          if (onDialogShow) {
-            onDialogShow();
-          }
-        });
-        if (!withoutNotifications) {
-          _this._notifyAboutShowing();
+        }();
+        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();
         }
+      });
+      if (!withoutNotifications) {
+        _this._notifyAboutShowing();
       }
-      return _this._dialogPromise;
-    };
-  })();
-  hideDialog = withoutNotifications => {
-    const {
-      onDialogHide
-    } = this.config;
-    this.reactRoot.render(null);
+    }
+    return _this._dialogPromise;
+  });
+  _defineProperty(this, "hideDialog", function (withoutNotifications) {
+    var onDialogHide = _this.config.onDialogHide;
+    _this.reactRoot.render(null);
     if (onDialogHide) {
       onDialogHide();
-      this._dialogPromise = null;
+      _this._dialogPromise = null;
       if (!withoutNotifications) {
-        this._notifyAboutHiding();
+        _this._notifyAboutHiding();
       }
     }
-  };
-  showDialogOrAlert = (withoutNotifications, preview, restOptions) => {
-    if (this.guest && !this.userAgreement.requiredForREST) {
-      return this.showAlert(withoutNotifications);
-    }
-    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();
+  });
+  _defineProperty(this, "showDialogOrAlert", function (withoutNotifications, preview, restOptions) {
+    if (_this.guest && !_this.userAgreement.requiredForREST) {
+      return _this.showAlert(withoutNotifications);
     }
-  };
-  onDecline = () => {
-    const {
-      onDecline
-    } = this.config;
-    this.hideDialog();
+    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();
     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 };