@jetbrains/ring-ui-built 6.0.1

package/components/permissions/permissions.js

@@ -0,0 +1,221 @@
+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
+        }
+      });
+    });
+    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/components/permissions/permissions__cache.d.ts

@@ -0,0 +1,93 @@
+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/components/permissions/permissions__cache.js

@@ -0,0 +1,257 @@
+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/components/popup/popup.consts.d.ts

@@ -0,0 +1,37 @@
+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/components/popup/popup.consts.js

@@ -0,0 +1,44 @@
+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 };