@jetbrains/ring-ui 4.2.7 → 4.2.10

package/dist/pager-ng/pager-ng.js

@@ -0,0 +1,100 @@
+import angularComponentFactory from '../global/angular-component-factory.js';
+import Pager$1 from '../pager/pager.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'angular';
+import 'react';
+import '../global/react-render-adapter.js';
+import 'react-dom';
+import '../global/ring-angular-component.js';
+import '../global/react-dom-renderer.js';
+import 'prop-types';
+import 'classnames';
+import '@jetbrains/icons/chevron-left';
+import '@jetbrains/icons/chevron-right';
+import '../button/button.js';
+import 'focus-visible';
+import '@jetbrains/icons/chevron-10px';
+import '../icon/icon.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon.js';
+import '../icon/icon__svg.js';
+import 'core-js/modules/es.string.replace.js';
+import '../global/memoize.js';
+import '../global/theme.js';
+import '../link/clickableLink.js';
+import '../_helpers/button__classes.js';
+import '../button-group/button-group.js';
+import '../button-group/caption.js';
+import '../_helpers/button-group.js';
+import '../button-toolbar/button-toolbar.js';
+import '../_helpers/button-toolbar.js';
+import '../select/select.js';
+import '@jetbrains/icons/close';
+import 'deep-equal';
+import '../dropdown/dropdown.js';
+import '../global/data-tests.js';
+import '../_helpers/anchor.js';
+import '../avatar/avatar.js';
+import '../global/url.js';
+import '../global/dom.js';
+import '../avatar/fallback-avatar.js';
+import '../global/get-uid.js';
+import '../popup/popup.js';
+import '../global/schedule-raf.js';
+import '../shortcuts/shortcuts.js';
+import '../shortcuts/core.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+import '../tab-trap/tab-trap.js';
+import '../popup/position.js';
+import '../popup/popup.consts.js';
+import '../popup/popup.target.js';
+import '../list/list.js';
+import 'react-virtualized/dist/es/List';
+import 'react-virtualized/dist/es/AutoSizer';
+import 'react-virtualized/dist/es/WindowScroller';
+import 'react-virtualized/dist/es/CellMeasurer';
+import 'memoize-one';
+import '../global/create-stateful-context.js';
+import '../list/list__link.js';
+import '../link/link.js';
+import '../_helpers/link.js';
+import '../_helpers/list.js';
+import '../list/list__item.js';
+import '../checkbox/checkbox.js';
+import '@jetbrains/icons/checkmark';
+import '@jetbrains/icons/remove-10px';
+import '../_helpers/checkbox.js';
+import '../list/list__custom.js';
+import '../global/get-event-key.js';
+import '../list/list__title.js';
+import '../list/list__separator.js';
+import '../list/list__hint.js';
+import '../list/consts.js';
+import '../input/input.js';
+import '../_helpers/input.js';
+import '../global/rerender-hoc.js';
+import '../global/composeRefs.js';
+import '../global/fuzzy-highlight.js';
+import '../select/select__popup.js';
+import '@jetbrains/icons/search';
+import '../loader-inline/loader-inline.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 '../shortcuts/shortcuts-hoc.js';
+import '../tags-list/tags-list.js';
+import '../tag/tag.js';
+import '../caret/caret.js';
+import '../text/text.js';
+import '../_helpers/select__filter.js';
+
+var Pager = angularComponentFactory(Pager$1, 'Pager').name;
+
+export { Pager as default };

package/dist/panel/panel.js

@@ -0,0 +1,31 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { m as modules_cf670408 } from '../_helpers/panel.js';
+
+/**
+ * @name Panel
+ */
+
+class Panel extends PureComponent {
+  render() {
+    const {
+      className,
+      children,
+      ...props
+    } = this.props;
+    const classes = classNames(modules_cf670408.panel, className);
+    return /*#__PURE__*/React.createElement("div", _extends({}, props, {
+      className: classes
+    }), children);
+  }
+
+}
+
+_defineProperty(Panel, "propTypes", {
+  className: PropTypes.string,
+  children: PropTypes.node
+});
+
+export { Panel as default };

package/dist/panel-ng/panel-ng.js

@@ -0,0 +1,17 @@
+import angular from 'angular';
+import { m as modules_cf670408 } from '../_helpers/panel.js';
+import { addClasses } from '../global/dom.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+const angularModule = angular.module('Ring.panel', []);
+angularModule.directive('rgPanel', function rgEqualValueDirective() {
+  return {
+    link: function link(scope, iElement) {
+      addClasses(iElement[0].classList, modules_cf670408.panel);
+    }
+  };
+});
+var panelNg = angularModule.name;
+
+export { panelNg as default };

package/dist/permissions/permissions.js

@@ -0,0 +1,200 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import PermissionCache from './permissions__cache.js';
+
+/**
+ * <code>
+ *   const permissions = new Permissions(auth, {prefix: 'jetbrains.jetpass.', services: [auth.serviceId]})
+ *   permissions.load().then(function (p) {
+ *     const canReadUser = p.has('read-user');
+ *     ...
+ *   });
+ *
+ *   permissions.check('read-user').then(function(canReadUser) {
+ *     ...
+ *   });
+ * </code>
+ *
+ * @param {Auth} auth instance of well configured Auth object
+ * @param {{
+ *   prefix: string?,
+ *   namesConverter: function?
+ *   serviceId: string?
+ * }=} config permissions loaded configuration.
+ * <code>prefix</code> if provided then this prefix is removed from the permissions names.
+ * <code>namesConverter</code> if provided it maps permission names used on server-side to client-side permission names. It is used only if prefix is undefined.
+ * <code>serviceId</code> if provided then permissions only for the service are loaded.
+ * @constructor
+ */
+
+class Permissions {
+  /**
+   * @const {string}
+   */
+  constructor(auth) {
+    let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+    _defineProperty(this, "_defaultDatasource", query => this._auth.http.get(Permissions.API_PERMISSION_CACHE_PATH, {
+      query: {
+        fields: 'permission/key,global,projects(id)',
+        query
+      }
+    }));
+
+    this.query = Permissions.getPermissionQuery(config.services);
+    this.namesConverter = config.prefix ? Permissions.getDefaultNamesConverter(config.prefix) : config.namesConverter;
+
+    if (!auth) {
+      throw new Error('Parameter auth is required');
+    }
+
+    this._auth = auth;
+    this._datasource = config.datasource || this._defaultDatasource;
+    this._promise = null;
+    this._subscribed = false;
+    this._permissionCache = new PermissionCache(null, this.namesConverter);
+  }
+
+  /**
+   * Returns function, which cuts off prefix from server-side permission name
+   *
+   * @param {string} prefix
+   * @returns {Function}
+   */
+  static getDefaultNamesConverter(prefix) {
+    return storedName => {
+      if (storedName.indexOf(prefix) !== 0) {
+        return storedName;
+      } else {
+        return storedName.substr(prefix.length);
+      }
+    };
+  }
+
+  static getPermissionQuery(services) {
+    if (!services || !services.length) {
+      return undefined;
+    }
+
+    return services.map(service => "service:{".concat(service, "}")).join(' or ');
+  }
+
+  set(cachedPermissions) {
+    this._permissionCache.set(cachedPermissions);
+
+    this._setCache(Promise.resolve(this._permissionCache));
+
+    return this._permissionCache;
+  }
+
+  get() {
+    return this._permissionCache.get();
+  }
+
+  _setCache(value) {
+    this._promise = value;
+    return value;
+  }
+
+  _getCache() {
+    return this._promise;
+  }
+
+  _resetCache() {
+    this._setCache(null);
+  }
+  /**
+   * Loads logged-in user permissions.
+   * @param {object?} options
+   * @return {Promise.<Permissions>} promise that is resolved when the permissions are loaded
+   */
+
+
+  load(options) {
+    if (this._subscribed === false) {
+      this._auth.addListener('userChange', () => {
+        this.reload();
+      });
+
+      this._subscribed = true;
+    }
+
+    if (!hasCacheControl('NO_CACHE', options) && this._getCache()) {
+      return this._getCache();
+    }
+
+    if (hasCacheControl('NO_STORE', options)) {
+      return this._loadPermissions().then(cachedPermissions => new PermissionCache(cachedPermissions, this.namesConverter));
+    }
+
+    return this._setCache(this._loadPermissions().then(cachedPermissions => this.set(cachedPermissions)));
+
+    function hasCacheControl(value, _options) {
+      if (_options && _options.cacheControl) {
+        return _options.cacheControl[value];
+      }
+
+      return false;
+    }
+  }
+
+  _loadPermissions() {
+    return this._datasource(this.query);
+  }
+  /**
+   * Reloads permission cache from server
+   * @returns {Promise.<Permissions>} promise that is resolved when the permissions are reloaded
+   */
+
+
+  reload() {
+    this._resetCache();
+
+    return this.load();
+  }
+  /**
+   * Waits till the permission cache is loaded then checks if the current user has the
+   * given permissions in the project with the given id.
+   *
+   * @param {string} permissions  space separated list of permissions
+   * @param {string=} projectId     optional projectId. If absent the method checks
+   *  if the given permission is granted in any project.
+   *
+   * @return {Promise.<boolean>}
+   */
+
+
+  check(permissions, projectId) {
+    return this.load().then(permissionCache => permissionCache.has(permissions, projectId));
+  }
+  /**
+   * Binds a property with the name <code>propertyName</code> of the <code>object</code>
+   * to a boolean value that is true if user has the permissions and false if she doesn't.
+   *
+   * @example
+   * <code>
+   *   userPermissions.bindVariable($scope, 'canReadRole', 'role-read')
+   * </code>
+   *
+   * @param {object} object       an object which property should be bound
+   * @param {string} propertyName a name of a property to bind
+   * @param {string} permissions  space separated list of permissions
+   * @param {string=} projectId     optional projectId. If absent the method checks
+   *  if the given permissions are granted in any project.
+   *
+   * @return {Promise.<boolean>}
+   */
+
+
+  bindVariable(object, propertyName, permissions, projectId) {
+    object[propertyName] = false;
+    return this.check(permissions, projectId).then(permitted => {
+      object[propertyName] = permitted;
+      return permitted;
+    });
+  }
+
+}
+
+_defineProperty(Permissions, "API_PERMISSION_CACHE_PATH", 'permissions/cache');
+
+export { Permissions as default };

package/dist/permissions/permissions__cache.js

@@ -0,0 +1,272 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+
+/**
+ * Converts an array of cached permissions to a a map of a permission key
+ * to the respective cached permission.
+ *
+ * @param { {
+ *   permission: {key: string},
+ *   global: boolean?,
+ *   projects: {id: string}[]?
+ * }[] } permissions
+ * @param {function} namesConverter a function, which maps a server-side permission name to client-side permission name
+ * @return {object} permission cache
+ * @private
+ */
+class PermissionCache {
+  /**
+   * Convert an array of projects to a set of project ids.
+   *
+   * @param {object[]=} projects
+   * @return {object} a set of project ids
+   * @private
+   */
+  static _toProjectIdSet(projects) {
+    let projectIdSet = null;
+
+    if (projects) {
+      projectIdSet = {};
+
+      for (let i = 0; i < projects.length; i++) {
+        projectIdSet[projects[i].id] = true;
+      }
+    }
+
+    return projectIdSet;
+  }
+
+  constructor(permissions, namesConverter) {
+    this.namesConverter = namesConverter || (key => key);
+
+    this.set(permissions);
+  }
+
+  set(permissions) {
+    const permissionCache = (permissions || []).reduce((_permissionCache, permission) => {
+      const key = this.namesConverter(permission.permission.key);
+
+      if (key) {
+        _permissionCache[key] = {
+          global: permission.global,
+          projectIdSet: this.constructor._toProjectIdSet(permission.projects)
+        };
+      }
+
+      return _permissionCache;
+    }, {});
+    this._permissions = permissions;
+    this.permissionCache = permissionCache;
+    return this;
+  }
+
+  get() {
+    return this._permissions;
+  }
+  /**
+   * Checks if the current user has the given permissions in the project with the given id.
+   *
+   * @param {string} permissions  space separated list of permissions
+   * @param {string=} projectId     optional projectId. If absent the method checks
+   *  if the given permission is granted in any project.
+   *
+   * @return {boolean}
+   */
+
+
+  has(permissions, projectId) {
+    const lexems = this.lex(permissions);
+
+    if (lexems.length === 0) {
+      return true;
+    }
+
+    try {
+      return this.or(lexems, projectId);
+    } catch (e) {
+      return false;
+    }
+  }
+  /**
+   * Lexes permission query string to an array of lexems.
+   *
+   * @param {string} query
+   * @return {string[]}
+   */
+
+
+  lex(query) {
+    const lexems = [];
+
+    if (query) {
+      let currentIdentifier = '';
+
+      for (let i = 0; i < query.length; i++) {
+        switch (query.charAt(i)) {
+          case ' ':
+          case '\t':
+          case '\n':
+          case '\r':
+            // Finish current token
+            if (currentIdentifier) {
+              lexems.push(currentIdentifier);
+              currentIdentifier = '';
+            } // Skip space
+
+
+            break;
+
+          case '(':
+          case ')':
+          case '&':
+          case '|':
+          case '!':
+            // Finish current token
+            if (currentIdentifier) {
+              lexems.push(currentIdentifier);
+              currentIdentifier = '';
+            } // Append operator
+
+
+            lexems.push(query.charAt(i));
+            break;
+
+          default:
+            currentIdentifier += query.charAt(i);
+            break;
+        }
+      }
+
+      if (currentIdentifier) {
+        lexems.push(currentIdentifier);
+      }
+    }
+
+    return lexems;
+  }
+  /*
+   or -> and ( '|' and )*
+   and -> not ( '&'?  not )*
+   not -> '!'* term
+   term -> '(' or ')' | permission
+   permission -> [^()&|!\s]+
+   */
+
+  /**
+   * @param {string[]} lexems
+   * @param {string=} projectId
+   * @return {boolean}
+   */
+
+
+  or(lexems, projectId) {
+    let result = this.and(lexems, projectId);
+
+    while (lexems.length > 0 && lexems[0] !== ')') {
+      if (lexems.shift() !== '|') {
+        throw new Error('Operator \'|\' was expected');
+      }
+
+      result = this.and(lexems, projectId) || result;
+    }
+
+    return result;
+  }
+  /**
+   * @param {string[]} lexems
+   * @param {string=} projectId
+   * @return {boolean}
+   */
+
+
+  and(lexems, projectId) {
+    let result = this.not(lexems, projectId);
+
+    while (lexems.length > 0 && lexems[0] !== ')' && lexems[0] !== '|') {
+      // Expect optional '&'
+      if (lexems[0] === '&') {
+        lexems.shift();
+      }
+
+      result = this.not(lexems, projectId) && result;
+    }
+
+    return result;
+  }
+  /**
+   * @param {string[]} lexems
+   * @param {string=} projectId
+   * @return {boolean}
+   */
+
+
+  not(lexems, projectId) {
+    let notCounter = 0;
+
+    while (lexems.length > 0 && lexems[0] === '!') {
+      ++notCounter;
+      lexems.shift();
+    }
+
+    const result = this.term(lexems, projectId);
+    return notCounter % 2 === 0 ? result : !result;
+  }
+  /**
+   * @param {string[]} lexems
+   * @param {string=} projectId
+   * @return {boolean}
+   */
+
+
+  term(lexems, projectId) {
+    if (lexems.length === 0) {
+      throw new Error('Operand was expected');
+    }
+
+    const t = lexems.shift();
+    let result; // Nested parenthesized expression
+
+    if (t === '(') {
+      result = this.or(lexems, projectId); // Expect ')'
+
+      if (lexems.shift() !== ')') {
+        throw new Error('Operator \')\' was expected');
+      }
+    } else {
+      result = this.testPermission(t, projectId);
+    }
+
+    return result;
+  }
+  /**
+   * @param {string} permissionName
+   * @param {string=} projectId
+   * @return {boolean}
+   */
+
+
+  testPermission(permissionName, projectId) {
+    const permissionCache = this.permissionCache;
+    const cachedPermission = permissionCache[permissionName] || permissionCache[this.namesConverter(permissionName)]; // Hasn't the permission in any project
+
+    if (!cachedPermission) {
+      return false;
+    } // The permission is global or is given in the global project
+
+
+    if (cachedPermission.global) {
+      return true;
+    }
+
+    if (projectId) {
+      // if projectId is specified check that the permission is given in the project
+      return cachedPermission.projectIdSet && projectId in cachedPermission.projectIdSet;
+    } else {
+      return true;
+    }
+  }
+
+}
+
+_defineProperty(PermissionCache, "GLOBAL_PROJECT_ID", 'global');
+
+export { PermissionCache as default };