@jetbrains/ring-ui-built 6.0.32 → 6.0.34

package/components/permissions/permissions__cache.js

@@ -1,3 +1,7 @@
+import { _ as _defineProperty, b as _createClass, f 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.
@@ -11,216 +15,242 @@
  * @return {object} permission cache
  * @private
  */
-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);
+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);
   }
-  _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;
+  return _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;
     }
-    try {
-      return this.or(lexems, projectId);
-    } catch (e) {
-      return false;
+  }, {
+    key: "get",
+    value: function get() {
+      return this._permissions;
     }
-  }
-  /**
-   * 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;
-        }
+    /**
+     * 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;
       }
-      if (currentIdentifier) {
-        lexems.push(currentIdentifier);
+      try {
+        return this.or(lexems, projectId);
+      } catch (e) {
+        return false;
       }
     }
-    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');
+    /**
+     * 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);
+        }
       }
-      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();
+    /*
+     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;
       }
-      result = this.not(lexems, projectId) && result;
+      return 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');
+    /**
+     * @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;
     }
-    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');
+    /**
+     * @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();
       }
-    } else {
-      result = t != null && this.testPermission(t, projectId);
+      var result = this.term(lexems, projectId);
+      return notCounter % 2 === 0 ? result : !result;
     }
-    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;
+    /**
+     * @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;
     }
-    // The permission is global or is given in the global project
-    if (cachedPermission.global) {
-      return true;
+    /**
+     * @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;
+      }
     }
-    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;
     }
-  }
-}
+  }]);
+}();
+_defineProperty(PermissionCache, "GLOBAL_PROJECT_ID", 'global');
 
 export { PermissionCache as default };

package/components/popup/popup.consts.js

@@ -17,7 +17,7 @@ var Directions;
  * When positioning a popup, directions will be tried in the listed order.
  * @type {Array.<string>}
  */
-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];
+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}
  */