@jetbrains/ring-ui 4.1.6 → 5.0.0-beta.3

package/components/permissions/permissions__cache.js

@@ -12,248 +12,217 @@
  * @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;
-      }
+    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;
     }
-
-    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;
+    namesConverter;
+    constructor(permissions, namesConverter) {
+        this.namesConverter = namesConverter || (key => key);
+        this.set(permissions);
     }
-
-    try {
-      return this.or(lexems, projectId);
-    } catch (e) {
-      return false;
+    _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;
     }
-  }
-
-  /**
-   * 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 = '';
+    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;
+                }
             }
-            // Skip space
-            break;
-          case '(':
-          case ')':
-          case '&':
-          case '|':
-          case '!':
-            // Finish current token
             if (currentIdentifier) {
-              lexems.push(currentIdentifier);
-              currentIdentifier = '';
+                lexems.push(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 lexems;
     }
-
-    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');
+    /*
+     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;
     }
-
-    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);
+    /**
+     * @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;
     }
-
-    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;
+    /**
+     * @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;
     }
-
-    // The permission is global or is given in the global project
-    if (cachedPermission.global) {
-      return true;
+    /**
+     * @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;
     }
-
-    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;
+    /**
+     * @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/permissions-ng/permissions-ng.examples.js

@@ -4,9 +4,9 @@ import angularDecorator, {APP_NAME} from '../../.storybook/angular-decorator';
 
 import hubConfig from '../../.storybook/hub-config';
 
-import AuthNG from '@jetbrains/ring-ui/components/auth-ng/auth-ng';
+import AuthNG from '../auth-ng/auth-ng';
 
-import PermissionsNG from '@jetbrains/ring-ui/components/permissions-ng/permissions-ng';
+import PermissionsNG from './permissions-ng';
 
 export default {
   title: 'Legacy Angular/Permissions Ng',

package/components/place-under-ng/place-under-ng.examples.js

@@ -2,9 +2,9 @@ import angular from 'angular';
 
 import angularDecorator, {APP_NAME} from '../../.storybook/angular-decorator';
 
-import {getDocumentScrollTop} from '@jetbrains/ring-ui/components/global/dom';
+import {getDocumentScrollTop} from '../global/dom';
 
-import RingPlaceUnder from '@jetbrains/ring-ui/components/place-under-ng/place-under-ng';
+import RingPlaceUnder from './place-under-ng';
 
 export default {
   title: 'Legacy Angular/Place Under Ng',

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

@@ -1,45 +1,45 @@
-export const 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'
-};
-
+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
+    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 const Dimension = {
-  MARGIN: 16,
-  BORDER_WIDTH: 1
-};
-
-export const MinWidth = {
-  TARGET: -1
-};
-
-export const MaxHeight = {
-  SCREEN: -1
-};
-
-export const Display = {
-  HIDDEN: 0,
-  SHOWING: 1,
-  SHOWN: 2
-};
+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 = {}));