@jetbrains/ring-ui 6.0.3-beta.0 → 6.0.3

package/dist/permissions/permissions.js

@@ -1,221 +0,0 @@
-import { _ as _defineProperty, d as _createClass, c as _classCallCheck } from '../_helpers/_rollupPluginBabelHelpers.js';
-import 'core-js/modules/es.object.to-string.js';
-import 'core-js/modules/es.promise.js';
-import 'core-js/modules/es.array.index-of.js';
-import 'core-js/modules/es.array.map.js';
-import PermissionCache from './permissions__cache.js';
-import 'core-js/modules/es.array.reduce.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
- */
-var Permissions = /*#__PURE__*/function () {
-  function Permissions(auth) {
-    var _this = this;
-    var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    _classCallCheck(this, Permissions);
-    _defineProperty(this, "query", void 0);
-    _defineProperty(this, "namesConverter", void 0);
-    _defineProperty(this, "_auth", void 0);
-    _defineProperty(this, "_datasource", void 0);
-    _defineProperty(this, "_promise", void 0);
-    _defineProperty(this, "_subscribed", void 0);
-    _defineProperty(this, "_permissionCache", void 0);
-    _defineProperty(this, "_defaultDatasource", function (query) {
-      return _this._auth.http.get(Permissions.API_PERMISSION_CACHE_PATH, {
-        query: {
-          fields: 'permission/key,global,projects(id)',
-          query: 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);
-  }
-  _createClass(Permissions, [{
-    key: "set",
-    value: function set(cachedPermissions) {
-      this._permissionCache.set(cachedPermissions);
-      this._setCache(Promise.resolve(this._permissionCache));
-      return this._permissionCache;
-    }
-  }, {
-    key: "get",
-    value: function get() {
-      return this._permissionCache.get();
-    }
-  }, {
-    key: "_setCache",
-    value: function _setCache(value) {
-      this._promise = value;
-    }
-  }, {
-    key: "_getCache",
-    value: function _getCache() {
-      return this._promise;
-    }
-  }, {
-    key: "_resetCache",
-    value: function _resetCache() {
-      this._setCache(null);
-    }
-    /**
-     * Loads logged-in user permissions.
-     * @param {object?} options
-     * @return {Promise.<Permissions>} promise that is resolved when the permissions are loaded
-     */
-  }, {
-    key: "load",
-    value: function load(options) {
-      var _this2 = this;
-      if (this._subscribed === false) {
-        this._auth.addListener('userChange', function () {
-          _this2.reload();
-        });
-        this._subscribed = true;
-      }
-      var cache = this._getCache();
-      if (!hasCacheControl('NO_CACHE', options) && cache) {
-        return cache;
-      }
-      if (hasCacheControl('NO_STORE', options)) {
-        return this._loadPermissions().then(function (cachedPermissions) {
-          return new PermissionCache(cachedPermissions, _this2.namesConverter);
-        });
-      }
-      var permissions = this._loadPermissions().then(function (cachedPermissions) {
-        return _this2.set(cachedPermissions);
-      });
-      this._setCache(permissions);
-      return permissions;
-      function hasCacheControl(value, _options) {
-        if (_options && _options.cacheControl) {
-          return _options.cacheControl[value];
-        }
-        return false;
-      }
-    }
-  }, {
-    key: "_loadPermissions",
-    value: function _loadPermissions() {
-      return this._datasource(this.query);
-    }
-    /**
-     * Reloads permission cache from server
-     * @returns {Promise.<Permissions>} promise that is resolved when the permissions are reloaded
-     */
-  }, {
-    key: "reload",
-    value: function 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>}
-     */
-  }, {
-    key: "check",
-    value: function check(permissions, projectId) {
-      return this.load().then(function (permissionCache) {
-        return 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>}
-     */
-  }, {
-    key: "bindVariable",
-    value: function bindVariable(object, propertyName, permissions, projectId) {
-      object[propertyName] = false;
-      return this.check(permissions, projectId).then(function (permitted) {
-        object[propertyName] = permitted;
-        return permitted;
-      });
-    }
-  }], [{
-    key: "getDefaultNamesConverter",
-    value:
-    /**
-     * Returns function, which cuts off prefix from server-side permission name
-     *
-     * @param {string} prefix
-     * @returns {Function}
-     */
-    function getDefaultNamesConverter(prefix) {
-      return function (storedName) {
-        if (storedName.indexOf(prefix) !== 0) {
-          return storedName;
-        } else {
-          return storedName.substr(prefix.length);
-        }
-      };
-    }
-  }, {
-    key: "getPermissionQuery",
-    value: function getPermissionQuery(services) {
-      if (!services || !services.length) {
-        return undefined;
-      }
-      return services.map(function (service) {
-        return "service:{".concat(service, "}");
-      }).join(' or ');
-    }
-  }]);
-  return Permissions;
-}();
-/**
- * @const {string}
- */
-_defineProperty(Permissions, "API_PERMISSION_CACHE_PATH", 'permissions/cache');
-
-export { Permissions as default };

package/dist/permissions/permissions__cache.d.ts

@@ -1,93 +0,0 @@
-export interface PermissionType {
-    key: string;
-}
-export interface Project {
-    id: string;
-}
-export interface Permission {
-    permission: PermissionType;
-    global?: boolean | null | undefined;
-    projects?: readonly Project[] | null | undefined;
-}
-interface PermissionCacheItem {
-    global: boolean | null | undefined;
-    projectIdSet: Record<string, boolean> | null;
-}
-/**
- * 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
- */
-export default class PermissionCache {
-    static GLOBAL_PROJECT_ID: string;
-    /**
-     * Convert an array of projects to a set of project ids.
-     *
-     * @param {object[]=} projects
-     * @return {object} a set of project ids
-     * @private
-     */
-    private static _toProjectIdSet;
-    namesConverter: (name: string) => string | null | undefined;
-    constructor(permissions?: readonly Permission[] | null | undefined, namesConverter?: ((name: string) => string | null | undefined) | null | undefined);
-    private _permissions?;
-    permissionCache?: Record<string, PermissionCacheItem>;
-    set(permissions?: readonly Permission[] | null | undefined): this;
-    get(): readonly Permission[] | null | undefined;
-    /**
-     * 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?: string | null | undefined, projectId?: string | null | undefined): boolean;
-    /**
-     * Lexes permission query string to an array of lexems.
-     *
-     * @param {string} query
-     * @return {string[]}
-     */
-    lex(query?: string | null | undefined): string[];
-    /**
-     * @param {string[]} lexems
-     * @param {string=} projectId
-     * @return {boolean}
-     */
-    or(lexems: string[], projectId?: string | null | undefined): boolean;
-    /**
-     * @param {string[]} lexems
-     * @param {string=} projectId
-     * @return {boolean}
-     */
-    and(lexems: string[], projectId?: string | null | undefined): boolean;
-    /**
-     * @param {string[]} lexems
-     * @param {string=} projectId
-     * @return {boolean}
-     */
-    not(lexems: string[], projectId?: string | null | undefined): boolean;
-    /**
-     * @param {string[]} lexems
-     * @param {string=} projectId
-     * @return {boolean}
-     */
-    term(lexems: string[], projectId?: string | null | undefined): boolean;
-    /**
-     * @param {string} permissionName
-     * @param {string=} projectId
-     * @return {boolean}
-     */
-    testPermission(permissionName: string, projectId?: string | null | undefined): boolean;
-}
-export {};

package/dist/permissions/permissions__cache.js

@@ -1,257 +0,0 @@
-import { _ as _defineProperty, d as _createClass, c as _classCallCheck } from '../_helpers/_rollupPluginBabelHelpers.js';
-import 'core-js/modules/es.array.reduce.js';
-import 'core-js/modules/es.object.to-string.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
- */
-var PermissionCache = /*#__PURE__*/function () {
-  function PermissionCache(permissions, namesConverter) {
-    _classCallCheck(this, PermissionCache);
-    _defineProperty(this, "namesConverter", void 0);
-    _defineProperty(this, "_permissions", void 0);
-    _defineProperty(this, "permissionCache", void 0);
-    this.namesConverter = namesConverter || function (key) {
-      return key;
-    };
-    this.set(permissions);
-  }
-  _createClass(PermissionCache, [{
-    key: "set",
-    value: function set(permissions) {
-      var _this = this;
-      var permissionCache = (permissions || []).reduce(function (_permissionCache, permission) {
-        var 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;
-    }
-  }, {
-    key: "get",
-    value: function 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}
-     */
-  }, {
-    key: "has",
-    value: function has(permissions, projectId) {
-      var 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[]}
-     */
-  }, {
-    key: "lex",
-    value: function lex(query) {
-      var lexems = [];
-      if (query) {
-        var currentIdentifier = '';
-        for (var 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}
-     */
-  }, {
-    key: "or",
-    value: function or(lexems, projectId) {
-      var 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}
-     */
-  }, {
-    key: "and",
-    value: function and(lexems, projectId) {
-      var 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}
-     */
-  }, {
-    key: "not",
-    value: function not(lexems, projectId) {
-      var notCounter = 0;
-      while (lexems.length > 0 && lexems[0] === '!') {
-        ++notCounter;
-        lexems.shift();
-      }
-      var result = this.term(lexems, projectId);
-      return notCounter % 2 === 0 ? result : !result;
-    }
-    /**
-     * @param {string[]} lexems
-     * @param {string=} projectId
-     * @return {boolean}
-     */
-  }, {
-    key: "term",
-    value: function term(lexems, projectId) {
-      if (lexems.length === 0) {
-        throw new Error('Operand was expected');
-      }
-      var t = lexems.shift();
-      var result;
-      // Nested parenthesized expression
-      if (t === '(') {
-        result = this.or(lexems, projectId);
-        // Expect ')'
-        if (lexems.shift() !== ')') {
-          throw new Error('Operator \')\' was expected');
-        }
-      } else {
-        result = t != null && this.testPermission(t, projectId);
-      }
-      return result;
-    }
-    /**
-     * @param {string} permissionName
-     * @param {string=} projectId
-     * @return {boolean}
-     */
-  }, {
-    key: "testPermission",
-    value: function testPermission(permissionName, projectId) {
-      var permissionCache = this.permissionCache;
-      var convertedName = this.namesConverter(permissionName);
-      var cachedPermission = (permissionCache === null || permissionCache === void 0 ? void 0 : permissionCache[permissionName]) || convertedName && (permissionCache === null || permissionCache === void 0 ? void 0 : permissionCache[convertedName]);
-      // 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 != null && projectId in cachedPermission.projectIdSet;
-      } else {
-        return true;
-      }
-    }
-  }], [{
-    key: "_toProjectIdSet",
-    value:
-    /**
-     * Convert an array of projects to a set of project ids.
-     *
-     * @param {object[]=} projects
-     * @return {object} a set of project ids
-     * @private
-     */
-    function _toProjectIdSet(projects) {
-      var projectIdSet = null;
-      if (projects) {
-        projectIdSet = {};
-        for (var i = 0; i < projects.length; i++) {
-          projectIdSet[projects[i].id] = true;
-        }
-      }
-      return projectIdSet;
-    }
-  }]);
-  return PermissionCache;
-}();
-_defineProperty(PermissionCache, "GLOBAL_PROJECT_ID", 'global');
-
-export { PermissionCache as default };

package/dist/popup/popup.consts.d.ts

@@ -1,37 +0,0 @@
-export declare enum Directions {
-    BOTTOM_RIGHT = "BOTTOM_RIGHT",
-    BOTTOM_LEFT = "BOTTOM_LEFT",
-    BOTTOM_CENTER = "BOTTOM_CENTER",
-    TOP_LEFT = "TOP_LEFT",
-    TOP_RIGHT = "TOP_RIGHT",
-    TOP_CENTER = "TOP_CENTER",
-    RIGHT_TOP = "RIGHT_TOP",
-    RIGHT_BOTTOM = "RIGHT_BOTTOM",
-    RIGHT_CENTER = "RIGHT_CENTER",
-    LEFT_TOP = "LEFT_TOP",
-    LEFT_BOTTOM = "LEFT_BOTTOM",
-    LEFT_CENTER = "LEFT_CENTER"
-}
-/**
- * When positioning a popup, directions will be tried in the listed order.
- * @type {Array.<string>}
- */
-export declare const DEFAULT_DIRECTIONS: Directions[];
-/**
- * @enum {number}
- */
-export declare enum Dimension {
-    MARGIN = 16,
-    BORDER_WIDTH = 1
-}
-export declare enum MinWidth {
-    TARGET = -1
-}
-export declare enum MaxHeight {
-    SCREEN = -1
-}
-export declare enum Display {
-    HIDDEN = 0,
-    SHOWING = 1,
-    SHOWN = 2
-}

package/dist/popup/popup.consts.js

@@ -1,44 +0,0 @@
-var Directions;
-(function (Directions) {
-  Directions["BOTTOM_RIGHT"] = "BOTTOM_RIGHT";
-  Directions["BOTTOM_LEFT"] = "BOTTOM_LEFT";
-  Directions["BOTTOM_CENTER"] = "BOTTOM_CENTER";
-  Directions["TOP_LEFT"] = "TOP_LEFT";
-  Directions["TOP_RIGHT"] = "TOP_RIGHT";
-  Directions["TOP_CENTER"] = "TOP_CENTER";
-  Directions["RIGHT_TOP"] = "RIGHT_TOP";
-  Directions["RIGHT_BOTTOM"] = "RIGHT_BOTTOM";
-  Directions["RIGHT_CENTER"] = "RIGHT_CENTER";
-  Directions["LEFT_TOP"] = "LEFT_TOP";
-  Directions["LEFT_BOTTOM"] = "LEFT_BOTTOM";
-  Directions["LEFT_CENTER"] = "LEFT_CENTER";
-})(Directions || (Directions = {}));
-/**
- * When positioning a popup, directions will be tried in the listed order.
- * @type {Array.<string>}
- */
-var DEFAULT_DIRECTIONS = [Directions.BOTTOM_RIGHT, Directions.BOTTOM_LEFT, Directions.TOP_LEFT, Directions.TOP_RIGHT, Directions.RIGHT_TOP, Directions.RIGHT_BOTTOM, Directions.LEFT_TOP, Directions.LEFT_BOTTOM];
-/**
- * @enum {number}
- */
-var Dimension;
-(function (Dimension) {
-  Dimension[Dimension["MARGIN"] = 16] = "MARGIN";
-  Dimension[Dimension["BORDER_WIDTH"] = 1] = "BORDER_WIDTH";
-})(Dimension || (Dimension = {}));
-var MinWidth;
-(function (MinWidth) {
-  MinWidth[MinWidth["TARGET"] = -1] = "TARGET";
-})(MinWidth || (MinWidth = {}));
-var MaxHeight;
-(function (MaxHeight) {
-  MaxHeight[MaxHeight["SCREEN"] = -1] = "SCREEN";
-})(MaxHeight || (MaxHeight = {}));
-var Display;
-(function (Display) {
-  Display[Display["HIDDEN"] = 0] = "HIDDEN";
-  Display[Display["SHOWING"] = 1] = "SHOWING";
-  Display[Display["SHOWN"] = 2] = "SHOWN";
-})(Display || (Display = {}));
-
-export { DEFAULT_DIRECTIONS, Dimension, Directions, Display, MaxHeight, MinWidth };