@jetbrains/ring-ui 4.1.1 → 4.1.2

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

@@ -0,0 +1,170 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React from 'react';
+import { render } from 'react-dom';
+import getUID from '../global/get-uid.js';
+import Alert, { ANIMATION_TIME } from '../alert/alert.js';
+import Alerts from '../alert/container.js';
+import 'classnames';
+import 'prop-types';
+import '@jetbrains/icons/exception';
+import '@jetbrains/icons/checkmark';
+import '@jetbrains/icons/warning';
+import '@jetbrains/icons/close';
+import '../icon/icon.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon.js';
+import '../icon/icon__svg.js';
+import '../global/memoize.js';
+import '../loader-inline/loader-inline.js';
+import '../global/theme.js';
+import '../global/data-tests.js';
+import '../_helpers/inject-styles.js';
+import '../global/conic-gradient.js';
+import 'conic-gradient';
+import '../global/supports-css.js';
+import '../global/inject-styles.js';
+import '../global/radial-gradient-mask.js';
+import '../global/dom.js';
+
+/**
+ * @name Alert Service
+ */
+
+class AlertService {
+  constructor() {
+    _defineProperty(this, "defaultTimeout", 0);
+
+    _defineProperty(this, "showingAlerts", []);
+
+    _defineProperty(this, "containerElement", document.createElement('div'));
+  }
+
+  _getShowingAlerts() {
+    return [...this.showingAlerts];
+  }
+
+  renderAlertContainer(alerts) {
+    if (alerts.length === 0) {
+      return /*#__PURE__*/React.createElement("span", null);
+    }
+
+    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;
+    }
+
+    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;
+      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;
+      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();
+
+export { alertService as default };

package/dist/analytics/analytics.js

@@ -0,0 +1,116 @@
+/**
+ * @name Analytics
+ */
+class Analytics {
+  constructor() {
+    this._plugins = [];
+  }
+
+  config(plugins) {
+    this._plugins = plugins;
+  }
+
+  track(rawTrackingData,
+  /* optional */
+  additionalData) {
+    if (!rawTrackingData) {
+      return;
+    }
+
+    let splitIdx = rawTrackingData.indexOf(':');
+
+    if (splitIdx < 0) {
+      splitIdx = rawTrackingData.indexOf('_');
+    }
+
+    if (splitIdx < 0) {
+      splitIdx = rawTrackingData.length;
+    }
+
+    const category = rawTrackingData.substr(0, splitIdx);
+    const subcategory = rawTrackingData.substr(splitIdx + 1);
+    this.trackEvent(category, subcategory, additionalData);
+  }
+
+  trackPageView(path) {
+    this._plugins.forEach(plugin => {
+      plugin.trackPageView(path);
+    });
+  }
+
+  trackEvent(category, action,
+  /* optional */
+  additionalData) {
+    const subaction = additionalData ? action + this._buildSuffix(additionalData) : null;
+
+    this._plugins.forEach(plugin => {
+      if (plugin.serializeAdditionalInfo) {
+        plugin.trackEvent(category, action);
+
+        if (subaction) {
+          plugin.trackEvent(category, subaction);
+        }
+      } else {
+        plugin.trackEvent(category, action, additionalData);
+      }
+    });
+  }
+
+  trackShortcutEvent(category, action,
+  /* optional */
+  additionalData) {
+    this.trackEvent(category, action, additionalData);
+    this.trackEvent('ring-shortcut', `${category}$${action}`, additionalData);
+  }
+
+  trackEntityProperties(entityName, entity, propertiesNames,
+  /* optional */
+  additionalData) {
+    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 (value.hasOwnProperty(keys[j])) {
+          value = value[keys[j]];
+        } else {
+          value = 'no-value';
+          break;
+        }
+      }
+
+      if (typeof value === 'string') {
+        value = value.toLowerCase().replace(/[._]+/g, '-');
+      }
+
+      const resultAction = `${keys.join('-')}__${value}`;
+      this.trackEvent(entityName, resultAction, additionalData);
+    }
+  }
+
+  _buildSuffix(additionalData) {
+    if (!additionalData) {
+      return '';
+    }
+
+    let suffix = '';
+    let key;
+
+    for (key in additionalData) {
+      if (additionalData.hasOwnProperty(key)) {
+        suffix += `__${key}$${additionalData[key]}`;
+      }
+    }
+
+    return suffix;
+  }
+
+}
+
+var analyticsInstance = new Analytics();
+
+export { analyticsInstance as default };

package/dist/analytics/analytics__custom-plugin.js

@@ -0,0 +1,127 @@
+import AnalyticsPluginUtils from './analytics__plugin-utils.js';
+import '../global/sniffer.js';
+import 'sniffr';
+
+const DEFAULT_FLUSH_INTERVAL = 10000;
+const DEFAULT_FLUSH_MAX_PACK_SIZE = 100;
+class AnalyticsCustomPlugin {
+  constructor(send, isDevelopment, flushInterval, flushingAllowedChecker) {
+    this._data = [];
+    this.config({
+      send,
+      isDevelopment,
+      flushInterval,
+      flushingAllowedChecker
+    });
+  }
+  /**
+   * @param config
+   * @property {function} config.send
+   * @property {boolean} config.isDevelopment
+   * @property {number} config.flushInterval
+   * @property {function} config.flushingAllowedChecker
+   * @property {number} config.flushMaxPackSize
+   */
+
+
+  config(config) {
+    let checkFlushingAllowed = config.flushingAllowedChecker;
+
+    if (typeof checkFlushingAllowed !== 'function') {
+      checkFlushingAllowed = () => true;
+    }
+
+    this._flush = () => {
+      if (this._data.length > 0 && checkFlushingAllowed()) {
+        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) {
+    this._processEvent(category, action);
+  }
+
+  trackPageView(path) {
+    if (this._lastPagePath === path) {
+      return;
+    }
+
+    this._trackPageViewAdditionalInfo(path);
+
+    this._processEvent('ring-page', path);
+
+    this._processEvent('ring-navigator_user-agent', AnalyticsPluginUtils.getUserAgentPresentation());
+
+    this._processEvent('ring-navigator_platform', AnalyticsPluginUtils.npeSaveLowerCase(navigator.platform));
+
+    this._processEvent('ring-navigator_lang', AnalyticsPluginUtils.npeSaveLowerCase(navigator.language));
+
+    this._processEvent('ring-device-pixel-ratio', AnalyticsPluginUtils.getDevicePixelRatioPresentation());
+
+    this._processEvent('ring-screen-width', AnalyticsPluginUtils.getScreenWidthPresentation());
+  }
+
+  _initSendSchedule() {
+    window.addEventListener('beforeunload', () => {
+      this._trackPageViewAdditionalInfo();
+
+      return this._flush();
+    });
+    setInterval(this._flush, this._flushInterval);
+    this._hasSendSchedule = true;
+  }
+
+  _processEvent(rawCategory, rawAction) {
+    if (!this._hasSendSchedule && this._flush) {
+      this._initSendSchedule();
+    }
+
+    const category = AnalyticsPluginUtils.reformatString(rawCategory, true);
+    const action = AnalyticsPluginUtils.reformatString(rawAction);
+
+    if (this._isDevelopment) {
+      console.log('TRACKING DATA = ', category, action); // eslint-disable-line no-console
+    }
+
+    this._addDataToFlushingPack({
+      category,
+      action
+    });
+  }
+
+  _trackPageViewAdditionalInfo(newPagePath) {
+    const currentTime = new Date().getTime();
+
+    if (this._lastPagePath) {
+      if (this._lastPageViewTime) {
+        const duration = AnalyticsPluginUtils.getPageViewDurationPresentation(currentTime - this._lastPageViewTime);
+
+        this._processEvent(`ring-pageview-duration_${this._lastPagePath}`, duration);
+      }
+    }
+
+    this._lastPageViewTime = currentTime;
+    this._lastPagePath = newPagePath;
+  }
+
+  _addDataToFlushingPack(sendingData) {
+    this._data.push(sendingData);
+
+    if (this._data.length >= this._flushMaxPackSize) {
+      this._flush();
+    }
+  }
+
+  get serializeAdditionalInfo() {
+    return true;
+  }
+
+}
+
+export { AnalyticsCustomPlugin as default };

package/dist/analytics/analytics__fus-plugin.js

@@ -0,0 +1,101 @@
+import AnalyticsPluginUtils from './analytics__plugin-utils.js';
+import '../global/sniffer.js';
+import 'sniffr';
+
+/**
+ * @name AnalyticsFUSPlugin
+ *
+ * @param * @param {{
+ *   productId: string,
+ *   productBuild: string,
+ *   recorderVersion: string?,
+ *   isDevelopment: boolean?,
+ *   groups: object[]?
+ * }} config
+ * @constructor
+ */
+
+class AnalyticsFUSPlugin {
+  constructor(_ref) {
+    let {
+      productId,
+      productBuild,
+      recorderVersion = '1',
+      isDevelopment = false,
+      groups = []
+    } = _ref;
+
+    if (!productId && !isDevelopment) {
+      return;
+    }
+
+    ((i, s, o, g, r) => {
+      i[r] = i[r] || function addArgumentsToQueueForWaitingTheScriptLoading() {
+        (i[r].query = i[r].query || []).push(arguments);
+      };
+
+      const script = document.createElement(o);
+      script.async = true;
+      script.src = g;
+      const firstScript = document.getElementsByTagName(o)[0];
+      firstScript.parentNode.insertBefore(script, firstScript);
+    })(window, document, 'script', '//resources.jetbrains.com/storage/fus/api/fus-reporting-api.js', 'fusra');
+    /* global fusra */
+
+
+    fusra('init', {
+      recorderCode: productId,
+      recorderVersion,
+      productCode: productId,
+      productBuild,
+      internal: isDevelopment,
+      groups,
+      useForSubdomains: true
+    });
+    this._recorderVersion = recorderVersion;
+    this._groups = groups;
+  }
+
+  trackEvent(category, action, additionalInfo) {
+    this._processEvent(category, action, additionalInfo);
+  }
+
+  trackPageView(path) {
+    if (this._lastPagePath === path) {
+      return;
+    }
+
+    this._lastPagePath = path;
+
+    this._processEvent('ring.page.view', 'open', {
+      path,
+      browser: AnalyticsPluginUtils.getUserAgentPresentation(),
+      platform: AnalyticsPluginUtils.npeSaveLowerCase(navigator.platform),
+      lang: AnalyticsPluginUtils.npeSaveLowerCase(navigator.language),
+      ['page-view-duration']: AnalyticsPluginUtils.getPageViewDurationPresentation(),
+      ['pixel-ratio']: AnalyticsPluginUtils.getDevicePixelRatioPresentation(),
+      screen: AnalyticsPluginUtils.getScreenWidthPresentation()
+    });
+  }
+
+  get serializeAdditionalInfo() {
+    return false;
+  }
+
+  _processEvent(category, action, additionalInfo) {
+    const groupId = category.replace(/[-]/g, '.');
+    const group = (this._groups || []).filter(currentGroup => currentGroup.id === groupId)[0];
+
+    if (group && window.fusra) {
+      fusra('event', {
+        groupId,
+        groupVersion: group.version || this._recorderVersion,
+        eventId: action,
+        eventData: additionalInfo
+      });
+    }
+  }
+
+}
+
+export { AnalyticsFUSPlugin as default };

package/dist/analytics/analytics__ga-plugin.js

@@ -0,0 +1,66 @@
+/**
+ *
+ * @param {string?} gaId Google Analytics ID (should be undefined in development)
+ * @constructor
+ */
+class AnalyticsGAPlugin {
+  constructor(gaId, isDevelopment, domain) {
+    if (!gaId && !isDevelopment) {
+      return;
+    }
+
+    ((i, s, o, g, r) => {
+      i.GoogleAnalyticsObject = r;
+
+      i[r] = i[r] || function addArgumentsToQueueForWaitingTheScriptLoading() {
+        (i[r].q = i[r].q || []).push(arguments);
+      };
+
+      i[r].l = 1 * new Date();
+      const a = s.createElement(o);
+      const m = s.getElementsByTagName(o)[0];
+      a.async = 1;
+      a.src = g;
+      m.parentNode.insertBefore(a, m);
+    })(window, document, 'script', '//www.google-analytics.com/analytics.js', 'ga');
+    /**
+     * UA-57284711-1 - ga key for development purpose
+     */
+
+
+    const key = gaId || 'UA-57284711-1';
+    /* global ga */
+
+    const gaCookieParams = domain ? {
+      cookieDomain: domain
+    } : {};
+    ga('create', key, !gaId ? {
+      cookieDomain: 'none'
+    } : gaCookieParams);
+    ga('set', 'anonymizeIp', true);
+    ga('set', 'allowAdFeatures', false);
+  }
+
+  trackEvent(category, action) {
+    if (window.ga) {
+      const eventOptions = {
+        eventCategory: category,
+        eventAction: action
+      };
+      ga('send', 'event', eventOptions);
+    }
+  }
+
+  trackPageView(path) {
+    if (window.ga) {
+      ga('send', 'pageview', path);
+    }
+  }
+
+  get serializeAdditionalInfo() {
+    return true;
+  }
+
+}
+
+export { AnalyticsGAPlugin as default };

package/dist/analytics/analytics__plugin-utils.js

@@ -0,0 +1,79 @@
+import sniffr from '../global/sniffer.js';
+import 'sniffr';
+
+const AnalyticsPluginUtils = {};
+const SECOND = 1000;
+const HOUR = 3600;
+/**
+ * Statistics server does not accept undefined values and strings containing certain symbols
+ * @param value
+ * @param isCategory
+ * @returns string, where forbidden symbols are replaced with '_'
+ */
+
+AnalyticsPluginUtils.reformatString = (value, isCategory) => {
+  const str = String(value);
+  /**
+   * Category also cannot contain the '/' character (but an action can)
+   */
+
+  const regexp = isCategory ? /[.:;!@#^&*(){}\[\]?,%=+\\\/]+/g : /[.:;!@#^&*(){}\[\]?,%=+\\]+/g;
+  return str.replace(regexp, '_');
+};
+
+AnalyticsPluginUtils.getPageViewDurationPresentation = durationMs => {
+  const duration = durationMs / SECOND;
+
+  if (duration > HOUR) {
+    return 'more-than-hour';
+  }
+  /**
+   * rounded duration possible values:
+   * less than 1 second: [0, 1)
+   * less than 2 seconds: [1, 2)
+   * less than 4 seconds: [2, 4)
+   * less than 16 seconds: [4, 16)
+   * ....
+   * n - less than 2^(n + 1) seconds
+   */
+
+
+  let roundedDuration = Math.floor(Math.pow(2, Math.floor(Math.log2(duration)) + 1));
+  roundedDuration = roundedDuration > 0 ? roundedDuration : 1;
+  return `less-than-${roundedDuration}-sec`;
+};
+
+AnalyticsPluginUtils.getScreenWidthPresentation = () => {
+  /**
+   * Sizes were taken from bootstrap's grid (xs, sm, md, lg)
+   */
+  // eslint-disable-next-line no-magic-numbers
+  const sizes = [0, 768, 992, 1200];
+
+  for (let i = 1; i < sizes.length; ++i) {
+    if (window.innerWidth < sizes[i]) {
+      return `[${sizes[i - 1]}px;${sizes[i]}px)`;
+    }
+  }
+
+  return '[1200px;inf)';
+};
+
+AnalyticsPluginUtils.npeSaveLowerCase = val => (val || 'unknown').toLowerCase();
+
+AnalyticsPluginUtils.getUserAgentPresentation = () => {
+  const name = AnalyticsPluginUtils.npeSaveLowerCase(sniffr.browser.name || 'unknown');
+  const majorVersion = sniffr.browser.version[0];
+  const version = majorVersion || 'unknown';
+  return `${name}$${version}`;
+};
+
+AnalyticsPluginUtils.getDevicePixelRatioPresentation = () => {
+  if (!window.devicePixelRatio || !window.devicePixelRatio.toFixed) {
+    return 'unknown';
+  }
+
+  return String(window.devicePixelRatio.toFixed(1));
+};
+
+export { AnalyticsPluginUtils as default };