@jetbrains/ring-ui-built 6.0.31 → 6.0.32

package/components/permissions/permissions.js

@@ -1,10 +1,4 @@
-import { _ as _defineProperty, b as _createClass, f as _classCallCheck } from '../_helpers/_rollupPluginBabelHelpers.js';
-import 'core-js/modules/es.array.index-of.js';
-import 'core-js/modules/es.array.map.js';
-import 'core-js/modules/es.object.to-string.js';
-import 'core-js/modules/es.promise.js';
 import PermissionCache from './permissions__cache.js';
-import 'core-js/modules/es.array.reduce.js';
 
 /**
  * <code>
@@ -30,26 +24,20 @@ import 'core-js/modules/es.array.reduce.js';
  * <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
-        }
-      });
-    });
+class Permissions {
+  /**
+   * @const {string}
+   */
+  static API_PERMISSION_CACHE_PATH = 'permissions/cache';
+  query;
+  namesConverter;
+  _auth;
+  _datasource;
+  _promise;
+  _subscribed;
+  _permissionCache;
+  constructor(auth) {
+    let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     this.query = Permissions.getPermissionQuery(config.services);
     this.namesConverter = config.prefix ? Permissions.getDefaultNamesConverter(config.prefix) : config.namesConverter;
     if (!auth) {
@@ -61,160 +49,127 @@ var Permissions = /*#__PURE__*/function () {
     this._subscribed = false;
     this._permissionCache = new PermissionCache(null, this.namesConverter);
   }
-  return _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;
+  _defaultDatasource = query => this._auth.http.get(Permissions.API_PERMISSION_CACHE_PATH, {
+    query: {
+      fields: 'permission/key,global,projects(id)',
+      query
     }
-  }, {
-    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;
+  });
+  /**
+   * 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);
       }
-      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();
+    };
+  }
+  static getPermissionQuery(services) {
+    if (!services || !services.length) {
+      return undefined;
     }
-    /**
-     * 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);
+    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;
     }
-    /**
-     * 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;
-      });
+    const cache = this._getCache();
+    if (!hasCacheControl('NO_CACHE', options) && cache) {
+      return cache;
     }
-  }], [{
-    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);
-        }
-      };
+    if (hasCacheControl('NO_STORE', options)) {
+      return this._loadPermissions().then(cachedPermissions => new PermissionCache(cachedPermissions, this.namesConverter));
     }
-  }, {
-    key: "getPermissionQuery",
-    value: function getPermissionQuery(services) {
-      if (!services || !services.length) {
-        return undefined;
+    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 services.map(function (service) {
-        return "service:{".concat(service, "}");
-      }).join(' or ');
+      return false;
     }
-  }]);
-}();
-/**
- * @const {string}
- */
-_defineProperty(Permissions, "API_PERMISSION_CACHE_PATH", 'permissions/cache');
+  }
+  _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;
+    });
+  }
+}
 
 export { Permissions as default };