@jetbrains/ring-ui-built 7.0.65 → 7.0.70

package/components/user-agreement/service.js

@@ -1,5 +1,3 @@
-import { _ as _defineProperty, b as _objectSpread2 } from '../_helpers/_rollupPluginBabelHelpers.js';
-import 'core-js/modules/web.dom-collections.iterator.js';
 import { jsxs, jsx } from 'react/jsx-runtime';
 import { createRoot } from 'react-dom/client';
 import LocalStorage from '../storage/storage-local.js';
@@ -25,8 +23,6 @@ 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 '../global/memoize.js';
 import '../loader-inline/loader-inline.js';
 import '../global/dom.js';
@@ -46,7 +42,6 @@ import 'sniffr';
 import '../tab-trap/tab-trap.js';
 import '../global/configuration.js';
 import '../popup/position.js';
-import 'core-js/modules/es.array.sort.js';
 import '../popup/popup.consts.js';
 import '../popup/position-css.js';
 import '../dialog/dialog.js';
@@ -87,271 +82,271 @@ function ignorePostponedCatchReason(reason) {
   throw reason;
 }
 class UserAgreementService {
+  config;
   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, "reactRoot", createRoot(this.container));
-    _defineProperty(this, "storage", new LocalStorage());
-    _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().catch(ignorePostponedCatchReason), this.interval);
-      window.addEventListener('storage', this.onStorageEvent);
-      this.checkConsentAndShowDialog().catch(ignorePostponedCatchReason);
-    });
-    _defineProperty(this, "stopChecking", () => {
-      clearInterval(this.intervalId);
-      window.removeEventListener('storage', this.onStorageEvent);
-      this.hideDialog();
-    });
-    _defineProperty(this, "onStorageEvent", event => {
-      if (event.key === storageKey && event.newValue) {
-        const {
-          tabId,
-          command
-        } = JSON.parse(event.newValue);
-        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 () => {
+    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 LocalStorage();
+  checkingPromise = null;
+  guest = false;
+  userAgreement = DEFAULT_AGREEMENT;
+  userConsent = DEFAULT_CONSENT;
+  intervalId;
+  startChecking = () => {
+    this.intervalId = window.setInterval(() => this.checkConsentAndShowDialog().catch(ignorePostponedCatchReason), this.interval);
+    window.addEventListener('storage', this.onStorageEvent);
+    this.checkConsentAndShowDialog().catch(ignorePostponedCatchReason);
+  };
+  stopChecking = () => {
+    clearInterval(this.intervalId);
+    window.removeEventListener('storage', this.onStorageEvent);
+    this.hideDialog();
+  };
+  onStorageEvent = event => {
+    if (event.key === storageKey && event.newValue !== null) {
       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);
-      }
-      return this.showDialogOrAlert(withoutNotifications);
-    });
-    _defineProperty(this, "checkConsent", async () => {
-      if (!this.checkingPromise) {
-        this.checkingPromise = Promise.all([this.getUserAgreement(), this.getUserConsent()]);
+        tabId,
+        command
+      } = JSON.parse(event.newValue);
+      if (tabId !== this.tabId) {
+        if (command === showMessage) {
+          this.checkConsentAndShowDialog(true);
+        } else if (command === hideMessage) {
+          this.hideDialogAndAlert(true);
+        }
       }
-      const [userAgreement, userConsent] = await this.checkingPromise;
-      this.checkingPromise = null;
-      const {
-        enabled,
-        majorVersion: actualVersion
-      } = userAgreement;
+    }
+  };
+  _notifyAboutShowing = () => {
+    localStorage.setItem(storageKey, JSON.stringify({
+      command: showMessage,
+      tabId: this.tabId
+    }));
+  };
+  _notifyAboutHiding = () => {
+    localStorage.setItem(storageKey, JSON.stringify({
+      command: hideMessage,
+      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);
+    }
+    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((resolve, reject) => {
       const {
-        accepted,
-        majorVersion: acceptedVersion
-      } = userConsent;
-      return !enabled || accepted && actualVersion === acceptedVersion;
+        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();
+      };
+      const message = jsxs(Group, {
+        children: [jsx("span", {
+          children: userAgreement || 'User Agreement'
+        }), jsx(Link, {
+          onClick: onReview,
+          "data-test": 'review',
+          children: reviewNow || 'Review now'
+        }), jsx(Link, {
+          onClick: onRemind,
+          "data-test": 'later',
+          children: remindLater || 'Remind me later'
+        })]
+      });
+      this.alertKey = alertService.addAlert(message, Alert.Type.WARNING, 0, {
+        closeable: false
+      });
     });
-    _defineProperty(this, "alertKey", void 0);
-    _defineProperty(this, "showAlert", 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);
-          reject('Postponed');
-        };
-        const onReview = async () => {
-          await this.showDialog(true, false, {
-            onRemindLater: onRemind
-          });
-          this.hideAlert(withoutNotifications);
+    if (!withoutNotifications) {
+      this._notifyAboutShowing();
+    }
+    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();
+    }
+  };
+  showDialog = (withoutNotifications, preview = false, restOptions) => {
+    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 message = jsxs(Group, {
-          children: [jsx("span", {
-            children: userAgreement || 'User Agreement'
-          }), jsx(Link, {
-            onClick: onReview,
-            "data-test": 'review',
-            children: reviewNow || 'Review now'
-          }), jsx(Link, {
-            onClick: onRemind,
-            "data-test": 'later',
-            children: remindLater || 'Remind me later'
-          })]
-        });
-        this.alertKey = alertService.addAlert(message, Alert.Type.WARNING, 0, {
-          closeable: false
-        });
+        const onDecline = async () => {
+          await this.onDecline();
+          reject();
+        };
+        const onClose = this.hideDialogAndAlert;
+        const props = {
+          children: content,
+          show,
+          onAccept,
+          onDecline,
+          onClose,
+          translations,
+          preview,
+          ...restOptions
+        };
+        this.reactRoot.render(jsx(ControlsHeightContext.Provider, {
+          value: getGlobalControlsHeight(),
+          children: jsx(UserAgreement, {
+            ...props
+          })
+        }));
+        if (onDialogShow) {
+          onDialogShow();
+        }
       });
       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();
-      }
+    }
+    return this._dialogPromise;
+  };
+  hideDialog = withoutNotifications => {
+    const {
+      onDialogHide
+    } = this.config;
+    this.reactRoot.render(null);
+    if (onDialogHide) {
+      onDialogHide();
+      this._dialogPromise = null;
       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 {
-        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();
-          };
-          const onClose = _this.hideDialogAndAlert;
-          const props = _objectSpread2({
-            children: content,
-            show,
-            onAccept,
-            onDecline,
-            onClose,
-            translations,
-            preview
-          }, restOptions);
-          _this.reactRoot.render(jsx(ControlsHeightContext.Provider, {
-            value: getGlobalControlsHeight(),
-            children: jsx(UserAgreement, _objectSpread2({}, props))
-          }));
-          if (onDialogShow) {
-            onDialogShow();
-          }
-        });
-        if (!withoutNotifications) {
-          _this._notifyAboutShowing();
-        }
-      }
-      return _this._dialogPromise;
-    });
-    _defineProperty(this, "hideDialog", withoutNotifications => {
-      const {
-        onDialogHide
-      } = this.config;
-      this.reactRoot.render(null);
-      if (onDialogHide) {
-        onDialogHide();
-        this._dialogPromise = null;
-        if (!withoutNotifications) {
-          this._notifyAboutHiding();
-        }
-      }
-    });
-    _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');
+  };
+  showDialogOrAlert = (withoutNotifications, preview, restOptions) => {
+    if (this.guest && !this.userAgreement.requiredForREST) {
+      return this.showAlert(withoutNotifications);
     }
-    if (!config.getUserConsent) {
-      throw new Error('Please pass a "getUserConsent" option to UserAgreementService');
+    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();
     }
-    if (!config.setUserConsent) {
-      throw new Error('Please pass a "setUserConsent" option to UserAgreementService');
+    this.hideDialog();
+    if (onAccept) {
+      onAccept();
     }
-    this.config = config;
-    this.interval = config.interval || this.interval;
-  }
+  };
+  onDecline = () => {
+    const {
+      onDecline
+    } = this.config;
+    this.hideDialog();
+    if (onDecline) {
+      onDecline();
+    }
+  };
 }
 
 export { UserAgreementService as default, hideMessage, showMessage };