@jetbrains/ring-ui 5.0.156 → 5.0.157

package/dist/alert-service/alert-service.js

@@ -1,10 +1,20 @@
-import { _ as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _createClass, g as _toConsumableArray, h as _objectWithoutProperties, i as _extends, a as _objectSpread2, b as _classCallCheck, c as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.array.concat.js';
 import React from 'react';
 import { render } from '../global/react-render-adapter.js';
 import getUID from '../global/get-uid.js';
 import Alert, { ANIMATION_TIME } from '../alert/alert.js';
 import Alerts from '../alert/container.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.string.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
 import 'react-dom';
+import 'core-js/modules/es.regexp.to-string.js';
+import 'core-js/modules/es.object.values.js';
 import 'classnames';
 import 'prop-types';
 import '@jetbrains/icons/exception';
@@ -16,11 +26,22 @@ import 'util-deprecate';
 import '../icon/icon__constants.js';
 import '../_helpers/icon.js';
 import '../icon/icon__svg.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.string.starts-with.js';
 import '../global/memoize.js';
+import 'core-js/modules/es.map.js';
 import '../loader-inline/loader-inline.js';
 import '../global/data-tests.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.entries.js';
 import '../_helpers/loader-inline.js';
 import '../global/dom.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.object.keys.js';
+import 'core-js/modules/es.set.js';
 import '../button/button.js';
 import '@jetbrains/icons/chevron-10px';
 import '../link/clickableLink.js';
@@ -32,124 +53,171 @@ 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';
 
+var _excluded = ["message", "key"],
+  _excluded2 = ["onCloseRequest", "onClose"];
 /**
  * @name Alert Service
  */
-class AlertService {
-  defaultTimeout = 0;
-  // This alerts are stored in inverse order (last shown is first in array)
-  showingAlerts = [];
-  containerElement = document.createElement('div');
-  _getShowingAlerts() {
-    return [...this.showingAlerts];
+var AlertService = /*#__PURE__*/function () {
+  function AlertService() {
+    _classCallCheck(this, AlertService);
+    _defineProperty(this, "defaultTimeout", 0);
+    // This alerts are stored in inverse order (last shown is first in array)
+    _defineProperty(this, "showingAlerts", []);
+    _defineProperty(this, "containerElement", document.createElement('div'));
   }
-  renderAlertContainer(alerts) {
-    if (alerts.length === 0) {
-      return /*#__PURE__*/React.createElement("span", null);
+  _createClass(AlertService, [{
+    key: "_getShowingAlerts",
+    value: function _getShowingAlerts() {
+      return _toConsumableArray(this.showingAlerts);
     }
-    return /*#__PURE__*/React.createElement(Alerts, null, alerts.map(alert => {
-      const {
-        message,
-        key,
-        ...rest
-      } = alert;
-      return /*#__PURE__*/React.createElement(Alert, _extends({
-        key: key
-      }, rest), message);
-    }));
-  }
-  /**
-   * Renders alert container into virtual node to skip maintaining container
-   */
-  renderAlerts() {
-    render(this.renderAlertContainer(this.showingAlerts), this.containerElement);
-  }
-  findSameAlert(message, type) {
-    return this.showingAlerts.filter(it => it.type === type && it.message === message)[0];
-  }
-  startAlertClosing(alert) {
-    alert.isClosing = true;
-    this.renderAlerts();
-  }
-  remove(key) {
-    const alertToClose = this.showingAlerts.filter(alert => alert.key === key)[0];
-    if (!alertToClose) {
-      return;
+  }, {
+    key: "renderAlertContainer",
+    value: function renderAlertContainer(alerts) {
+      if (alerts.length === 0) {
+        return /*#__PURE__*/React.createElement("span", null);
+      }
+      return /*#__PURE__*/React.createElement(Alerts, null, alerts.map(function (alert) {
+        var message = alert.message,
+          key = alert.key,
+          rest = _objectWithoutProperties(alert, _excluded);
+        return /*#__PURE__*/React.createElement(Alert, _extends({
+          key: key
+        }, rest), message);
+      }));
     }
-    this.startAlertClosing(alertToClose);
-  }
-  removeWithoutAnimation(key) {
-    this.showingAlerts = this.showingAlerts.filter(alert => alert.key !== key);
-    this.renderAlerts();
-  }
-  stopShakingWhenAnimationDone(shakingAlert) {
-    setTimeout(() => {
-      shakingAlert.showWithAnimation = false;
-      shakingAlert.isShaking = false;
+    /**
+     * Renders alert container into virtual node to skip maintaining container
+     */
+  }, {
+    key: "renderAlerts",
+    value: function renderAlerts() {
+      render(this.renderAlertContainer(this.showingAlerts), this.containerElement);
+    }
+  }, {
+    key: "findSameAlert",
+    value: function findSameAlert(message, type) {
+      return this.showingAlerts.filter(function (it) {
+        return it.type === type && it.message === message;
+      })[0];
+    }
+  }, {
+    key: "startAlertClosing",
+    value: function startAlertClosing(alert) {
+      alert.isClosing = true;
       this.renderAlerts();
-    }, ANIMATION_TIME);
-  }
-  addAlert(message, type) {
-    let timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.defaultTimeout;
-    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-    const {
-      onCloseRequest,
-      onClose,
-      ...restOptions
-    } = options;
-    const sameAlert = this.findSameAlert(message, type);
-    if (sameAlert) {
-      sameAlert.isShaking = true;
+    }
+  }, {
+    key: "remove",
+    value: function remove(key) {
+      var alertToClose = this.showingAlerts.filter(function (alert) {
+        return alert.key === key;
+      })[0];
+      if (!alertToClose) {
+        return;
+      }
+      this.startAlertClosing(alertToClose);
+    }
+  }, {
+    key: "removeWithoutAnimation",
+    value: function removeWithoutAnimation(key) {
+      this.showingAlerts = this.showingAlerts.filter(function (alert) {
+        return alert.key !== key;
+      });
       this.renderAlerts();
-      this.stopShakingWhenAnimationDone(sameAlert);
-      return sameAlert.key;
     }
-    const alert = {
-      key: getUID('alert-service-'),
-      message,
-      type,
-      timeout,
-      isClosing: false,
-      onCloseRequest: () => {
-        onCloseRequest && onCloseRequest();
-        this.startAlertClosing(alert);
-      },
-      onClose: () => {
-        onClose && onClose();
-        this.removeWithoutAnimation(alert.key);
-      },
-      ...restOptions
-    };
-    this.showingAlerts = [alert, ...this.showingAlerts];
-    this.renderAlerts();
-    return alert.key;
-  }
-  setDefaultTimeout(timeout) {
-    this.defaultTimeout = timeout;
-  }
-  error(message, timeout) {
-    return this.addAlert(message, Alert.Type.ERROR, timeout);
-  }
-  message(message, timeout) {
-    return this.addAlert(message, Alert.Type.MESSAGE, timeout);
-  }
-  warning(message, timeout) {
-    return this.addAlert(message, Alert.Type.WARNING, timeout);
-  }
-  successMessage(message, timeout) {
-    return this.addAlert(message, Alert.Type.SUCCESS, timeout);
-  }
-  loadingMessage(message, timeout) {
-    return this.addAlert(message, Alert.Type.LOADING, timeout);
-  }
-}
-const alertService = new AlertService();
+  }, {
+    key: "stopShakingWhenAnimationDone",
+    value: function stopShakingWhenAnimationDone(shakingAlert) {
+      var _this = this;
+      setTimeout(function () {
+        shakingAlert.showWithAnimation = false;
+        shakingAlert.isShaking = false;
+        _this.renderAlerts();
+      }, ANIMATION_TIME);
+    }
+  }, {
+    key: "addAlert",
+    value: function addAlert(message, type) {
+      var _this2 = this;
+      var timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.defaultTimeout;
+      var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+      var _onCloseRequest = options.onCloseRequest,
+        _onClose = options.onClose,
+        restOptions = _objectWithoutProperties(options, _excluded2);
+      var sameAlert = this.findSameAlert(message, type);
+      if (sameAlert) {
+        sameAlert.isShaking = true;
+        this.renderAlerts();
+        this.stopShakingWhenAnimationDone(sameAlert);
+        return sameAlert.key;
+      }
+      var alert = _objectSpread2({
+        key: getUID('alert-service-'),
+        message: message,
+        type: type,
+        timeout: timeout,
+        isClosing: false,
+        onCloseRequest: function onCloseRequest() {
+          _onCloseRequest && _onCloseRequest();
+          _this2.startAlertClosing(alert);
+        },
+        onClose: function onClose() {
+          _onClose && _onClose();
+          _this2.removeWithoutAnimation(alert.key);
+        }
+      }, restOptions);
+      this.showingAlerts = [alert].concat(_toConsumableArray(this.showingAlerts));
+      this.renderAlerts();
+      return alert.key;
+    }
+  }, {
+    key: "setDefaultTimeout",
+    value: function setDefaultTimeout(timeout) {
+      this.defaultTimeout = timeout;
+    }
+  }, {
+    key: "error",
+    value: function error(message, timeout) {
+      return this.addAlert(message, Alert.Type.ERROR, timeout);
+    }
+  }, {
+    key: "message",
+    value: function message(_message, timeout) {
+      return this.addAlert(_message, Alert.Type.MESSAGE, timeout);
+    }
+  }, {
+    key: "warning",
+    value: function warning(message, timeout) {
+      return this.addAlert(message, Alert.Type.WARNING, timeout);
+    }
+  }, {
+    key: "successMessage",
+    value: function successMessage(message, timeout) {
+      return this.addAlert(message, Alert.Type.SUCCESS, timeout);
+    }
+  }, {
+    key: "loadingMessage",
+    value: function loadingMessage(message, timeout) {
+      return this.addAlert(message, Alert.Type.LOADING, timeout);
+    }
+  }]);
+  return AlertService;
+}();
+var alertService = new AlertService();
 
 export { alertService as default };

package/dist/analytics/analytics.js

@@ -1,84 +1,108 @@
+import { _ as _createClass, d as _typeof, b as _classCallCheck, c as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.index-of.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.array.concat.js';
 import deprecate from 'util-deprecate';
 
-const warnOnDeprecationOfAnalyticsMethod = methodName => deprecate(() => {}, `Method analytics::${methodName} is deprecated, use analytics::trackEvent instead`)();
+var warnOnDeprecationOfAnalyticsMethod = function warnOnDeprecationOfAnalyticsMethod(methodName) {
+  return deprecate(function () {}, "Method analytics::".concat(methodName, " is deprecated, use analytics::trackEvent instead"))();
+};
 /**
  * @name Analytics
  */
-class Analytics {
-  _plugins;
-  constructor() {
+var Analytics = /*#__PURE__*/function () {
+  function Analytics() {
+    _classCallCheck(this, Analytics);
+    _defineProperty(this, "_plugins", void 0);
     this._plugins = [];
   }
-  config(plugins) {
-    this._plugins = plugins;
-  }
-  /**
-   * @deprecated
-   */
-  track(rawTrackingData, additionalData) {
-    if (!rawTrackingData) {
-      return;
+  _createClass(Analytics, [{
+    key: "config",
+    value: function config(plugins) {
+      this._plugins = plugins;
     }
-    warnOnDeprecationOfAnalyticsMethod('track');
-    let splitIdx = rawTrackingData.indexOf(':');
-    if (splitIdx < 0) {
-      splitIdx = rawTrackingData.indexOf('_');
+    /**
+     * @deprecated
+     */
+  }, {
+    key: "track",
+    value: function track(rawTrackingData, additionalData) {
+      if (!rawTrackingData) {
+        return;
+      }
+      warnOnDeprecationOfAnalyticsMethod('track');
+      var splitIdx = rawTrackingData.indexOf(':');
+      if (splitIdx < 0) {
+        splitIdx = rawTrackingData.indexOf('_');
+      }
+      if (splitIdx < 0) {
+        splitIdx = rawTrackingData.length;
+      }
+      var category = rawTrackingData.substr(0, splitIdx);
+      var subcategory = rawTrackingData.substr(splitIdx + 1);
+      this.trackEvent(category, subcategory, additionalData);
     }
-    if (splitIdx < 0) {
-      splitIdx = rawTrackingData.length;
+    /**
+     * @deprecated
+     */
+  }, {
+    key: "trackPageView",
+    value: function trackPageView(path) {
+      warnOnDeprecationOfAnalyticsMethod('trackPageView');
+      this._plugins.forEach(function (plugin) {
+        plugin.trackPageView(path);
+      });
     }
-    const category = rawTrackingData.substr(0, splitIdx);
-    const subcategory = rawTrackingData.substr(splitIdx + 1);
-    this.trackEvent(category, subcategory, additionalData);
-  }
-  /**
-   * @deprecated
-   */
-  trackPageView(path) {
-    warnOnDeprecationOfAnalyticsMethod('trackPageView');
-    this._plugins.forEach(plugin => {
-      plugin.trackPageView(path);
-    });
-  }
-  trackEvent(category, action, additionalData) {
-    this._plugins.forEach(plugin => {
-      plugin.trackEvent(category, action, additionalData);
-    });
-  }
-  /**
-   * @deprecated
-   */
-  trackShortcutEvent(category, action, additionalData) {
-    warnOnDeprecationOfAnalyticsMethod('trackShortcutEvent');
-    this.trackEvent(category, action, additionalData);
-  }
-  /**
-   * @deprecated
-   */
-  trackEntityProperties(entityName, entity, propertiesNames, additionalData) {
-    warnOnDeprecationOfAnalyticsMethod('trackEntityProperties');
-    for (let i = 0; i < propertiesNames.length; ++i) {
-      const keys = propertiesNames[i].split('.');
-      let value = entity;
-      if (!keys.length) {
-        continue;
-      }
-      for (let j = 0; j < keys.length; ++j) {
-        if (typeof value === 'object' && value != null && value.hasOwnProperty(keys[j])) {
-          value = value[keys[j]];
-        } else {
-          value = 'no-value';
-          break;
+  }, {
+    key: "trackEvent",
+    value: function trackEvent(category, action, additionalData) {
+      this._plugins.forEach(function (plugin) {
+        plugin.trackEvent(category, action, additionalData);
+      });
+    }
+    /**
+     * @deprecated
+     */
+  }, {
+    key: "trackShortcutEvent",
+    value: function trackShortcutEvent(category, action, additionalData) {
+      warnOnDeprecationOfAnalyticsMethod('trackShortcutEvent');
+      this.trackEvent(category, action, additionalData);
+    }
+    /**
+     * @deprecated
+     */
+  }, {
+    key: "trackEntityProperties",
+    value: function trackEntityProperties(entityName, entity, propertiesNames, additionalData) {
+      warnOnDeprecationOfAnalyticsMethod('trackEntityProperties');
+      for (var i = 0; i < propertiesNames.length; ++i) {
+        var keys = propertiesNames[i].split('.');
+        var value = entity;
+        if (!keys.length) {
+          continue;
         }
+        for (var j = 0; j < keys.length; ++j) {
+          if (_typeof(value) === 'object' && value != null && value.hasOwnProperty(keys[j])) {
+            value = value[keys[j]];
+          } else {
+            value = 'no-value';
+            break;
+          }
+        }
+        if (typeof value === 'string') {
+          value = value.toLowerCase().replace(/[._]+/g, '-');
+        }
+        var resultAction = "".concat(keys.join('-'), "__").concat(value);
+        this.trackEvent(entityName, resultAction, additionalData);
       }
-      if (typeof value === 'string') {
-        value = value.toLowerCase().replace(/[._]+/g, '-');
-      }
-      const resultAction = `${keys.join('-')}__${value}`;
-      this.trackEvent(entityName, resultAction, additionalData);
     }
-  }
-}
+  }]);
+  return Analytics;
+}();
 var analytics = new Analytics();
 
 export { Analytics, analytics as default };

package/dist/analytics/analytics__custom-plugin.js

@@ -1,71 +1,95 @@
-const DEFAULT_FLUSH_INTERVAL = 10000;
-const DEFAULT_FLUSH_MAX_PACK_SIZE = 100;
-class AnalyticsCustomPlugin {
-  _data;
-  _flush;
-  _isDevelopment;
-  _flushInterval;
-  _flushMaxPackSize;
-  _hasSendSchedule;
-  constructor(send, isDevelopment, flushInterval) {
+import { _ as _createClass, a as _objectSpread2, b as _classCallCheck, c as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+
+var DEFAULT_FLUSH_INTERVAL = 10000;
+var DEFAULT_FLUSH_MAX_PACK_SIZE = 100;
+var AnalyticsCustomPlugin = /*#__PURE__*/function () {
+  function AnalyticsCustomPlugin(send, isDevelopment, flushInterval) {
+    _classCallCheck(this, AnalyticsCustomPlugin);
+    _defineProperty(this, "_data", void 0);
+    _defineProperty(this, "_flush", void 0);
+    _defineProperty(this, "_isDevelopment", void 0);
+    _defineProperty(this, "_flushInterval", void 0);
+    _defineProperty(this, "_flushMaxPackSize", void 0);
+    _defineProperty(this, "_hasSendSchedule", void 0);
     this._data = [];
     this.config({
-      send,
-      isDevelopment,
-      flushInterval
+      send: send,
+      isDevelopment: isDevelopment,
+      flushInterval: flushInterval
     });
   }
-  config(config) {
-    this._flush = () => {
-      if (this._data.length > 0) {
-        config.send(this._data);
-        this._data = [];
-      }
-    };
-    this._isDevelopment = config.isDevelopment;
-    this._flushInterval = config.flushInterval || DEFAULT_FLUSH_INTERVAL;
-    this._flushMaxPackSize = config.flushMaxPackSize || DEFAULT_FLUSH_MAX_PACK_SIZE;
-  }
-  trackEvent(category, action, additionalData) {
-    this._processEvent(category, action, additionalData);
-  }
-  trackPageView(path, data) {
-    this._processEvent('page', 'view', data);
-  }
-  _initSendSchedule() {
-    window.addEventListener('beforeunload', () => this._flush?.());
-    if (this._flush != null) {
-      setInterval(this._flush, this._flushInterval);
+  _createClass(AnalyticsCustomPlugin, [{
+    key: "config",
+    value: function config(_config) {
+      var _this = this;
+      this._flush = function () {
+        if (_this._data.length > 0) {
+          _config.send(_this._data);
+          _this._data = [];
+        }
+      };
+      this._isDevelopment = _config.isDevelopment;
+      this._flushInterval = _config.flushInterval || DEFAULT_FLUSH_INTERVAL;
+      this._flushMaxPackSize = _config.flushMaxPackSize || DEFAULT_FLUSH_MAX_PACK_SIZE;
     }
-    this._hasSendSchedule = true;
-  }
-  _processEvent(category, action, data) {
-    if (!this._hasSendSchedule && this._flush) {
-      this._initSendSchedule();
+  }, {
+    key: "trackEvent",
+    value: function trackEvent(category, action, additionalData) {
+      this._processEvent(category, action, additionalData);
     }
-    if (this._isDevelopment) {
-      console.log('TRACKING DATA = ', category, action, data); // eslint-disable-line no-console
+  }, {
+    key: "trackPageView",
+    value: function trackPageView(path, data) {
+      this._processEvent('page', 'view', data);
+    }
+  }, {
+    key: "_initSendSchedule",
+    value: function _initSendSchedule() {
+      var _this2 = this;
+      window.addEventListener('beforeunload', function () {
+        var _this2$_flush;
+        return (_this2$_flush = _this2._flush) === null || _this2$_flush === void 0 ? void 0 : _this2$_flush.call(_this2);
+      });
+      if (this._flush != null) {
+        setInterval(this._flush, this._flushInterval);
+      }
+      this._hasSendSchedule = true;
     }
+  }, {
+    key: "_processEvent",
+    value: function _processEvent(category, action, data) {
+      if (!this._hasSendSchedule && this._flush) {
+        this._initSendSchedule();
+      }
+      if (this._isDevelopment) {
+        console.log('TRACKING DATA = ', category, action, data); // eslint-disable-line no-console
+      }
 
-    const baseSendingData = {
-      category,
-      action,
-      timestamp: Date.now()
-    };
-    this._addDataToFlushingPack(data ? {
-      ...baseSendingData,
-      data
-    } : baseSendingData);
-  }
-  _addDataToFlushingPack(sendingData) {
-    this._data.push(sendingData);
-    if (this._flushMaxPackSize != null && this._data.length >= this._flushMaxPackSize) {
-      this._flush?.();
+      var baseSendingData = {
+        category: category,
+        action: action,
+        timestamp: Date.now()
+      };
+      this._addDataToFlushingPack(data ? _objectSpread2(_objectSpread2({}, baseSendingData), {}, {
+        data: data
+      }) : baseSendingData);
     }
-  }
-  get serializeAdditionalInfo() {
-    return true;
-  }
-}
+  }, {
+    key: "_addDataToFlushingPack",
+    value: function _addDataToFlushingPack(sendingData) {
+      this._data.push(sendingData);
+      if (this._flushMaxPackSize != null && this._data.length >= this._flushMaxPackSize) {
+        var _this$_flush;
+        (_this$_flush = this._flush) === null || _this$_flush === void 0 ? void 0 : _this$_flush.call(this);
+      }
+    }
+  }, {
+    key: "serializeAdditionalInfo",
+    get: function get() {
+      return true;
+    }
+  }]);
+  return AnalyticsCustomPlugin;
+}();
 
 export { AnalyticsCustomPlugin as default };