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

package/components/permissions/permissions.js

@@ -0,0 +1,177 @@
+import PermissionCache from './permissions__cache';
+/**
+ * <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
+ */
+export default class Permissions {
+    /**
+     * @const {string}
+     */
+    static API_PERMISSION_CACHE_PATH = 'permissions/cache';
+    query;
+    namesConverter;
+    _auth;
+    _datasource;
+    _promise;
+    _subscribed;
+    _permissionCache;
+    constructor(auth, config = {}) {
+        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);
+    }
+    _defaultDatasource = (query) => (this._auth.http.get(Permissions.API_PERMISSION_CACHE_PATH, {
+        query: {
+            fields: 'permission/key,global,projects(id)',
+            query
+        }
+    }));
+    /**
+     * 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:{${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;
+    }
+    _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;
+        }
+        const cache = this._getCache();
+        if (!hasCacheControl('NO_CACHE', options) && cache) {
+            return cache;
+        }
+        if (hasCacheControl('NO_STORE', options)) {
+            return this._loadPermissions().
+                then(cachedPermissions => new PermissionCache(cachedPermissions, this.namesConverter));
+        }
+        const permissions = this._loadPermissions().
+            then(cachedPermissions => this.set(cachedPermissions));
+        this._setCache(permissions);
+        return permissions;
+        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;
+        });
+    }
+}

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,228 @@
+/**
+ * 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 = 'global';
+    /**
+     * 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;
+    }
+    namesConverter;
+    constructor(permissions, namesConverter) {
+        this.namesConverter = namesConverter || (key => key);
+        this.set(permissions);
+    }
+    _permissions;
+    permissionCache;
+    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 = t != null && this.testPermission(t, projectId);
+        }
+        return result;
+    }
+    /**
+     * @param {string} permissionName
+     * @param {string=} projectId
+     * @return {boolean}
+     */
+    testPermission(permissionName, projectId) {
+        const permissionCache = this.permissionCache;
+        const convertedName = this.namesConverter(permissionName);
+        const cachedPermission = permissionCache?.[permissionName] ||
+            convertedName && 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;
+        }
+    }
+}

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,45 @@
+export 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>}
+ */
+export const 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}
+ */
+export var Dimension;
+(function (Dimension) {
+    Dimension[Dimension["MARGIN"] = 16] = "MARGIN";
+    Dimension[Dimension["BORDER_WIDTH"] = 1] = "BORDER_WIDTH";
+})(Dimension || (Dimension = {}));
+export var MinWidth;
+(function (MinWidth) {
+    MinWidth[MinWidth["TARGET"] = -1] = "TARGET";
+})(MinWidth || (MinWidth = {}));
+export var MaxHeight;
+(function (MaxHeight) {
+    MaxHeight[MaxHeight["SCREEN"] = -1] = "SCREEN";
+})(MaxHeight || (MaxHeight = {}));
+export var Display;
+(function (Display) {
+    Display[Display["HIDDEN"] = 0] = "HIDDEN";
+    Display[Display["SHOWING"] = 1] = "SHOWING";
+    Display[Display["SHOWN"] = 2] = "SHOWN";
+})(Display || (Display = {}));

package/components/popup/popup.css

@@ -0,0 +1,34 @@
+@import "../global/variables.css";
+
+.popup {
+  composes: font from "../global/global.css";
+
+  position: fixed;
+  z-index: var(--ring-overlay-z-index);
+  top: -100vh;
+  left: -100vw;
+
+  overflow-y: auto;
+
+  box-sizing: border-box;
+
+  border: 1px solid var(--ring-popup-border-color);
+  border-radius: var(--ring-border-radius);
+
+  background-color: var(--ring-popup-background-color);
+  box-shadow: var(--ring-popup-shadow);
+}
+
+.hidden {
+  display: none;
+}
+
+.showing {
+  opacity: 0;
+}
+
+.attached {
+  border-top: 0;
+  border-top-left-radius: 0;
+  border-top-right-radius: 0;
+}