@jetbrains/ring-ui 4.2.7 → 4.2.10

package/dist/analytics/analytics__custom-plugin.js

@@ -0,0 +1,128 @@
+import AnalyticsPluginUtils from './analytics__plugin-utils.js';
+import 'core-js/modules/es.string.replace.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_".concat(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,102 @@
+import 'core-js/modules/es.string.replace.js';
+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,75 @@
+/**
+ *
+ * @param {string?} gaId Google Analytics ID (should be undefined in development)
+ * @constructor
+ */
+class AnalyticsGAPlugin {
+  constructor(gaId, isDevelopment, domain, cookielessUserIdentifier) {
+    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 */
+
+    if (cookielessUserIdentifier) {
+      ga('create', key, {
+        storage: 'none',
+        clientId: cookielessUserIdentifier
+      });
+    } else {
+      const gaCookieParams = domain ? {
+        cookieDomain: domain
+      } : {};
+      ga('create', key, !gaId ? {
+        cookieDomain: 'none'
+      } : gaCookieParams);
+    }
+
+    ga('set', 'anonymizeIp', true);
+    ga('set', 'location', domain || '/');
+    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,80 @@
+import 'core-js/modules/es.string.replace.js';
+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-".concat(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 "[".concat(sizes[i - 1], "px;").concat(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 "".concat(name, "$").concat(version);
+};
+
+AnalyticsPluginUtils.getDevicePixelRatioPresentation = () => {
+  if (!window.devicePixelRatio || !window.devicePixelRatio.toFixed) {
+    return 'unknown';
+  }
+
+  return String(window.devicePixelRatio.toFixed(1));
+};
+
+export { AnalyticsPluginUtils as default };

package/dist/analytics-ng/analytics-ng.js

@@ -0,0 +1,95 @@
+import angular from 'angular';
+import analyticsInstance from '../analytics/analytics.js';
+import AnalyticsGAPlugin from '../analytics/analytics__ga-plugin.js';
+import AnalyticsFUSPlugin from '../analytics/analytics__fus-plugin.js';
+import AnalyticsCustomPlugin from '../analytics/analytics__custom-plugin.js';
+import 'core-js/modules/es.string.replace.js';
+import '../analytics/analytics__plugin-utils.js';
+import '../global/sniffer.js';
+import 'sniffr';
+
+/**
+ * @name Analytics Ng
+*/
+
+const angularModule = angular.module('Ring.analytics', []);
+/**
+ * @name analyticsProvider
+ * @description Configures analytics with plugins.
+ */
+
+angularModule.provider('analytics', function provider() {
+  let configPlugins = [];
+  /**
+   * @param plugins
+   */
+
+  this.plugins = plugins => {
+    configPlugins = plugins;
+  };
+
+  this.$get = ["$log", "$injector", function get($log, $injector) {
+    const loadedPlugins = [];
+
+    for (let i = 0; i < configPlugins.length; ++i) {
+      if (typeof configPlugins[i] === 'string') {
+        try {
+          const plugin = $injector.get(configPlugins[i]);
+          loadedPlugins.push(plugin);
+          $log.debug("analytics: loaded plugin ".concat(configPlugins[i]));
+        } catch (err) {
+          $log.debug("analytics: unable to load factory ".concat(configPlugins[i]));
+        }
+      } else {
+        loadedPlugins.push(configPlugins[i]);
+      }
+    }
+
+    analyticsInstance.config(loadedPlugins);
+    return analyticsInstance;
+  }];
+});
+angularModule.constant('AnalyticsGAPlugin', AnalyticsGAPlugin);
+angularModule.constant('AnalyticsCustomPlugin', AnalyticsCustomPlugin);
+angularModule.constant('AnalyticsFUSPlugin', AnalyticsFUSPlugin);
+/**
+ * Enable page tracking
+ */
+
+angularModule.run(["$rootScope", "analytics", function analyticsRun($rootScope, analytics) {
+  $rootScope.$on('$routeChangeSuccess', (evt, current) => {
+    // eslint-disable-line angular/on-watch
+
+    /* eslint-disable angular/no-private-call */
+    if (current && current.$$route && current.$$route.originalPath) {
+      analytics.trackPageView(current.$$route.originalPath);
+    }
+    /* eslint-enable angular/no-private-call */
+
+  });
+}]);
+/**
+ *  @ngdoc directive
+ *  @name rg-analytics
+ *
+ *  @description
+ *  The `rg-analytics="<categoryName>:<eventName>"` sends categoryName and eventName to analytics server on
+ *  user action, specified via attribute `rg-analytics-on` (e.g. rg-analytics-on='mouseover' means that analytics will be sent on mouseover,
+ *  rg-analytics-on='click' - on click). If there is no attribute rg-analytics-on, the default value 'click' is used.
+ */
+
+angularModule.directive('rgAnalytics', ["analytics", function rgAnalyticsDirective(analytics) {
+  return {
+    restrict: 'A',
+    replace: false,
+    link: function link($scope, elem) {
+      const eventType = elem.attr('rg-analytics-on') || 'click';
+      angular.element(elem).bind(eventType, () => {
+        analytics.track(elem.attr('rg-analytics'));
+      });
+    }
+  };
+}]);
+var analyticsNg = angularModule.name;
+
+export { analyticsNg as default };

package/dist/auth/auth.js

@@ -0,0 +1,96 @@
+import WindowFlow from './window-flow.js';
+import onBackendDown from './down-notification.js';
+import Auth from './auth__core.js';
+export { DEFAULT_BACKGROUND_TIMEOUT, DEFAULT_EXPIRES_TIMEOUT, DOMAIN_USER_CHANGED_EVENT, LOGOUT_EVENT, LOGOUT_POSTPONED_EVENT, USER_CHANGED_EVENT, USER_CHANGE_POSTPONED_EVENT, default } from './auth__core.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import './response-parser.js';
+import 'core-js/modules/es.string.replace.js';
+import 'es6-error';
+import '../global/url.js';
+import 'react';
+import 'prop-types';
+import '../alert-service/alert-service.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import '../global/react-render-adapter.js';
+import 'react-dom';
+import '../global/get-uid.js';
+import '../alert/alert.js';
+import 'classnames';
+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';
+import '../alert/container.js';
+import '../link/link.js';
+import 'focus-visible';
+import '../link/clickableLink.js';
+import '../_helpers/link.js';
+import '../group/group.js';
+import '../_helpers/group.js';
+import '../global/listeners.js';
+import '../http/http.js';
+import '../global/promise-with-timeout.js';
+import './storage.js';
+import '../storage/storage.js';
+import '../storage/storage__local.js';
+import '../storage/storage__fallback.js';
+import 'deep-equal';
+import './request-builder.js';
+import 'simply-uuid';
+import './background-flow.js';
+import './token-validator.js';
+
+/**
+ * @name Auth
+ *
+ * @prop {object} config
+ * @prop {string} config.serverUri
+ * @prop {string} config.redirectUri
+ * @prop {string} config.clientId
+ * @prop {boolean=false} config.redirect — use redirects instead of loading the token in the background.
+ * @prop {string[]} config.scope
+ * @prop {string[]} config.optionalScopes
+ * @prop {boolean} config.cleanHash - whether or not location.hash will be cleaned after authorization is completed.
+ * Should be set to false in angular > 1.2.26 apps to prevent infinite redirect in Firefox
+ * @prop {User?} user
+ * @prop {string[]} config.userFields List of user data fields to be returned by auth.requestUser (default list is used in Header.HeaderHelper)
+ * @prop {string[]} config.fetchCredentials
+ *
+ * @param {{
+ *   serverUri: string,
+ *   redirectUri: string?,
+ *   requestCredentials: string?,
+ *   clientId: string?,
+ *   scope: string[]?,
+ *   optionalScopes: string[]?,
+ *   cleanHash: boolean?,
+ *   fetchCredentials: string?,
+ *   userFields: string[]?
+ * }} config
+ *
+ */
+
+/**
+ * Extend Auth config with non-required and not pure-JS stuff
+ */
+
+Auth.DEFAULT_CONFIG = { ...Auth.DEFAULT_CONFIG,
+  EmbeddedLoginFlow: WindowFlow,
+  onBackendDown: onBackendDown
+};