@jetbrains/ring-ui 5.1.23 → 5.1.24

package/dist/panel-ng/panel-ng.js

@@ -0,0 +1,26 @@
+import angular from 'angular';
+import { m as modules_cf670408 } from '../_helpers/panel.js';
+import { addClasses } from '../global/dom.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.set.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+var angularModule = angular.module('Ring.panel', []);
+angularModule.directive('rgPanel', function rgEqualValueDirective() {
+  return {
+    link: function link(scope, iElement) {
+      addClasses(iElement[0].classList, modules_cf670408.panel);
+    }
+  };
+});
+var panelNg = angularModule.name;
+
+export { panelNg as default };

package/dist/permissions/permissions.d.ts

@@ -0,0 +1,111 @@
+import Auth from '../auth/auth__core';
+import PermissionCache, { Permission } from './permissions__cache';
+export interface PermissionsConfig {
+    prefix?: string | null | undefined;
+    namesConverter?: ((name: string) => string) | null | undefined;
+    services?: readonly string[] | null | undefined;
+    datasource?: ((query: string | undefined) => Promise<readonly Permission[] | null | undefined>) | null | undefined;
+}
+interface PermissionsCacheControl {
+    NO_CACHE?: boolean | null | undefined;
+    NO_STORE?: boolean | null | undefined;
+}
+export interface PermissionsLoadOptions {
+    cacheControl?: PermissionsCacheControl | null | undefined;
+}
+/**
+ * <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: string;
+    query: string | undefined;
+    namesConverter: ((name: string) => string) | null | undefined;
+    private _auth;
+    private _datasource;
+    _promise: Promise<PermissionCache> | null;
+    private _subscribed;
+    private _permissionCache;
+    constructor(auth: Auth, config?: PermissionsConfig);
+    private _defaultDatasource;
+    /**
+     * Returns function, which cuts off prefix from server-side permission name
+     *
+     * @param {string} prefix
+     * @returns {Function}
+     */
+    static getDefaultNamesConverter(prefix: string): (storedName: string) => string;
+    static getPermissionQuery(services?: readonly string[] | null | undefined): string | undefined;
+    set(cachedPermissions?: readonly Permission[] | null | undefined): PermissionCache;
+    get(): readonly Permission[] | null | undefined;
+    private _setCache;
+    private _getCache;
+    private _resetCache;
+    /**
+     * Loads logged-in user permissions.
+     * @param {object?} options
+     * @return {Promise.<Permissions>} promise that is resolved when the permissions are loaded
+     */
+    load(options?: PermissionsLoadOptions | null | undefined): Promise<PermissionCache>;
+    _loadPermissions(): Promise<readonly Permission[] | null | undefined>;
+    /**
+     * Reloads permission cache from server
+     * @returns {Promise.<Permissions>} promise that is resolved when the permissions are reloaded
+     */
+    reload(): Promise<PermissionCache>;
+    /**
+     * 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?: string | null | undefined, projectId?: string | null | undefined): Promise<boolean>;
+    /**
+     * 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<K extends string>(object: {
+        [key in K]?: boolean;
+    }, propertyName: K, permissions?: string | null | undefined, projectId?: string | null | undefined): Promise<boolean>;
+}
+export {};

package/dist/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/dist/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 {};