@yelon/acl 12.0.13 → 12.0.17

package/esm2015/src/acl.service.js

@@ -1,195 +1,195 @@
-import { Injectable } from '@angular/core';
-import { BehaviorSubject } from 'rxjs';
-import { YunzaiConfigService } from '@yelon/util/config';
-import { ACL_DEFAULT_CONFIG } from './acl.config';
-/**
- * ACL 控制服务，[在线文档](https://ng.yunzainfo.com/acl)
- *
- * 务必在根目录注册 `YelonACLModule.forRoot()` 才能使用服务
- */
-export class ACLService {
-    constructor(configSrv) {
-        this.roles = [];
-        this.abilities = [];
-        this.full = false;
-        this.aclChange = new BehaviorSubject(null);
-        this.options = configSrv.merge('acl', ACL_DEFAULT_CONFIG);
-    }
-    /** ACL变更通知 */
-    get change() {
-        return this.aclChange.asObservable();
-    }
-    /** 获取所有数据 */
-    get data() {
-        return {
-            full: this.full,
-            roles: this.roles,
-            abilities: this.abilities
-        };
-    }
-    get guard_url() {
-        return this.options.guard_url;
-    }
-    parseACLType(val) {
-        let t;
-        if (typeof val === 'number') {
-            t = { ability: [val] };
-        }
-        else if (Array.isArray(val) && val.length > 0 && typeof val[0] === 'number') {
-            t = { ability: val };
-        }
-        else if (typeof val === 'object' && !Array.isArray(val)) {
-            t = Object.assign({}, val);
-        }
-        else if (Array.isArray(val)) {
-            t = { role: val };
-        }
-        else {
-            t = { role: val == null ? [] : [val] };
-        }
-        return Object.assign({ except: false }, t);
-    }
-    /**
-     * 设置当前用户角色或权限能力（会先清除所有）
-     */
-    set(value) {
-        this.full = false;
-        this.abilities = [];
-        this.roles = [];
-        this.add(value);
-        this.aclChange.next(value);
-    }
-    /**
-     * 标识当前用户为全量，即不受限
-     */
-    setFull(val) {
-        this.full = val;
-        this.aclChange.next(val);
-    }
-    /**
-     * 设置当前用户权限能力（会先清除所有）
-     */
-    setAbility(abilities) {
-        this.set({ ability: abilities });
-    }
-    /**
-     * 设置当前用户角色（会先清除所有）
-     */
-    setRole(roles) {
-        this.set({ role: roles });
-    }
-    /**
-     * 为当前用户增加角色或权限能力
-     */
-    add(value) {
-        if (value.role && value.role.length > 0) {
-            this.roles.push(...value.role);
-        }
-        if (value.ability && value.ability.length > 0) {
-            this.abilities.push(...value.ability);
-        }
-    }
-    /**
-     * 为当前用户附加角色
-     */
-    attachRole(roles) {
-        for (const val of roles) {
-            if (!this.roles.includes(val)) {
-                this.roles.push(val);
-            }
-        }
-        this.aclChange.next(this.data);
-    }
-    /**
-     * 为当前用户附加权限
-     */
-    attachAbility(abilities) {
-        for (const val of abilities) {
-            if (!this.abilities.includes(val)) {
-                this.abilities.push(val);
-            }
-        }
-        this.aclChange.next(this.data);
-    }
-    /**
-     * 为当前用户移除角色
-     */
-    removeRole(roles) {
-        for (const val of roles) {
-            const idx = this.roles.indexOf(val);
-            if (idx !== -1) {
-                this.roles.splice(idx, 1);
-            }
-        }
-        this.aclChange.next(this.data);
-    }
-    /**
-     * 为当前用户移除权限
-     */
-    removeAbility(abilities) {
-        for (const val of abilities) {
-            const idx = this.abilities.indexOf(val);
-            if (idx !== -1) {
-                this.abilities.splice(idx, 1);
-            }
-        }
-        this.aclChange.next(this.data);
-    }
-    /**
-     * 当前用户是否有对应角色，其实 `number` 表示Ability
-     *
-     * - 当 `full: true` 或参数 `null` 时返回 `true`
-     * - 若使用 `ACLType` 参数，可以指定 `mode` 校验模式
-     */
-    can(roleOrAbility) {
-        const { preCan } = this.options;
-        if (preCan) {
-            roleOrAbility = preCan(roleOrAbility);
-        }
-        const t = this.parseACLType(roleOrAbility);
-        let result = false;
-        if (this.full === true || !roleOrAbility) {
-            result = true;
-        }
-        else {
-            if (t.role && t.role.length > 0) {
-                if (t.mode === 'allOf') {
-                    result = t.role.every(v => this.roles.includes(v));
-                }
-                else {
-                    result = t.role.some(v => this.roles.includes(v));
-                }
-            }
-            if (t.ability && t.ability.length > 0) {
-                if (t.mode === 'allOf') {
-                    result = t.ability.every(v => this.abilities.includes(v));
-                }
-                else {
-                    result = t.ability.some(v => this.abilities.includes(v));
-                }
-            }
-        }
-        return t.except === true ? !result : result;
-    }
-    /** @inner */
-    parseAbility(value) {
-        if (typeof value === 'number' || typeof value === 'string' || Array.isArray(value)) {
-            value = { ability: Array.isArray(value) ? value : [value] };
-        }
-        delete value.role;
-        return value;
-    }
-    /**
-     * 当前用户是否有对应权限点
-     */
-    canAbility(value) {
-        return this.can(this.parseAbility(value));
-    }
-}
-ACLService.decorators = [
-    { type: Injectable }
-];
-ACLService.ctorParameters = () => [
-    { type: YunzaiConfigService }
-];
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { YunzaiConfigService } from '@yelon/util/config';
+import { ACL_DEFAULT_CONFIG } from './acl.config';
+/**
+ * ACL 控制服务，[在线文档](https://ng.yunzainfo.com/acl)
+ *
+ * 务必在根目录注册 `YelonACLModule.forRoot()` 才能使用服务
+ */
+export class ACLService {
+    constructor(configSrv) {
+        this.roles = [];
+        this.abilities = [];
+        this.full = false;
+        this.aclChange = new BehaviorSubject(null);
+        this.options = configSrv.merge('acl', ACL_DEFAULT_CONFIG);
+    }
+    /** ACL变更通知 */
+    get change() {
+        return this.aclChange.asObservable();
+    }
+    /** 获取所有数据 */
+    get data() {
+        return {
+            full: this.full,
+            roles: this.roles,
+            abilities: this.abilities
+        };
+    }
+    get guard_url() {
+        return this.options.guard_url;
+    }
+    parseACLType(val) {
+        let t;
+        if (typeof val === 'number') {
+            t = { ability: [val] };
+        }
+        else if (Array.isArray(val) && val.length > 0 && typeof val[0] === 'number') {
+            t = { ability: val };
+        }
+        else if (typeof val === 'object' && !Array.isArray(val)) {
+            t = Object.assign({}, val);
+        }
+        else if (Array.isArray(val)) {
+            t = { role: val };
+        }
+        else {
+            t = { role: val == null ? [] : [val] };
+        }
+        return Object.assign({ except: false }, t);
+    }
+    /**
+     * 设置当前用户角色或权限能力（会先清除所有）
+     */
+    set(value) {
+        this.full = false;
+        this.abilities = [];
+        this.roles = [];
+        this.add(value);
+        this.aclChange.next(value);
+    }
+    /**
+     * 标识当前用户为全量，即不受限
+     */
+    setFull(val) {
+        this.full = val;
+        this.aclChange.next(val);
+    }
+    /**
+     * 设置当前用户权限能力（会先清除所有）
+     */
+    setAbility(abilities) {
+        this.set({ ability: abilities });
+    }
+    /**
+     * 设置当前用户角色（会先清除所有）
+     */
+    setRole(roles) {
+        this.set({ role: roles });
+    }
+    /**
+     * 为当前用户增加角色或权限能力
+     */
+    add(value) {
+        if (value.role && value.role.length > 0) {
+            this.roles.push(...value.role);
+        }
+        if (value.ability && value.ability.length > 0) {
+            this.abilities.push(...value.ability);
+        }
+    }
+    /**
+     * 为当前用户附加角色
+     */
+    attachRole(roles) {
+        for (const val of roles) {
+            if (!this.roles.includes(val)) {
+                this.roles.push(val);
+            }
+        }
+        this.aclChange.next(this.data);
+    }
+    /**
+     * 为当前用户附加权限
+     */
+    attachAbility(abilities) {
+        for (const val of abilities) {
+            if (!this.abilities.includes(val)) {
+                this.abilities.push(val);
+            }
+        }
+        this.aclChange.next(this.data);
+    }
+    /**
+     * 为当前用户移除角色
+     */
+    removeRole(roles) {
+        for (const val of roles) {
+            const idx = this.roles.indexOf(val);
+            if (idx !== -1) {
+                this.roles.splice(idx, 1);
+            }
+        }
+        this.aclChange.next(this.data);
+    }
+    /**
+     * 为当前用户移除权限
+     */
+    removeAbility(abilities) {
+        for (const val of abilities) {
+            const idx = this.abilities.indexOf(val);
+            if (idx !== -1) {
+                this.abilities.splice(idx, 1);
+            }
+        }
+        this.aclChange.next(this.data);
+    }
+    /**
+     * 当前用户是否有对应角色，其实 `number` 表示Ability
+     *
+     * - 当 `full: true` 或参数 `null` 时返回 `true`
+     * - 若使用 `ACLType` 参数，可以指定 `mode` 校验模式
+     */
+    can(roleOrAbility) {
+        const { preCan } = this.options;
+        if (preCan) {
+            roleOrAbility = preCan(roleOrAbility);
+        }
+        const t = this.parseACLType(roleOrAbility);
+        let result = false;
+        if (this.full === true || !roleOrAbility) {
+            result = true;
+        }
+        else {
+            if (t.role && t.role.length > 0) {
+                if (t.mode === 'allOf') {
+                    result = t.role.every(v => this.roles.includes(v));
+                }
+                else {
+                    result = t.role.some(v => this.roles.includes(v));
+                }
+            }
+            if (t.ability && t.ability.length > 0) {
+                if (t.mode === 'allOf') {
+                    result = t.ability.every(v => this.abilities.includes(v));
+                }
+                else {
+                    result = t.ability.some(v => this.abilities.includes(v));
+                }
+            }
+        }
+        return t.except === true ? !result : result;
+    }
+    /** @inner */
+    parseAbility(value) {
+        if (typeof value === 'number' || typeof value === 'string' || Array.isArray(value)) {
+            value = { ability: Array.isArray(value) ? value : [value] };
+        }
+        delete value.role;
+        return value;
+    }
+    /**
+     * 当前用户是否有对应权限点
+     */
+    canAbility(value) {
+        return this.can(this.parseAbility(value));
+    }
+}
+ACLService.decorators = [
+    { type: Injectable }
+];
+ACLService.ctorParameters = () => [
+    { type: YunzaiConfigService }
+];
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"acl.service.js","sourceRoot":"","sources":["../../../../../packages/acl/src/acl.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject, Observable } from 'rxjs';\n\nimport { YunzaiACLConfig, YunzaiConfigService } from '@yelon/util/config';\n\nimport { ACL_DEFAULT_CONFIG } from './acl.config';\nimport { ACLCanType, ACLType } from './acl.type';\n\n/**\n * ACL 控制服务，[在线文档](https://ng.yunzainfo.com/acl)\n *\n * 务必在根目录注册 `YelonACLModule.forRoot()` 才能使用服务\n */\n@Injectable()\nexport class ACLService {\n  private options: YunzaiACLConfig;\n  private roles: string[] = [];\n  private abilities: Array<number | string> = [];\n  private full = false;\n  private aclChange = new BehaviorSubject<ACLType | boolean | null>(null);\n\n  /** ACL变更通知 */\n  get change(): Observable<ACLType | boolean | null> {\n    return this.aclChange.asObservable();\n  }\n\n  /** 获取所有数据 */\n  get data(): { full: boolean; roles: string[]; abilities: Array<string | number> } {\n    return {\n      full: this.full,\n      roles: this.roles,\n      abilities: this.abilities\n    };\n  }\n\n  get guard_url(): string {\n    return this.options.guard_url!;\n  }\n\n  constructor(configSrv: YunzaiConfigService) {\n    this.options = configSrv.merge('acl', ACL_DEFAULT_CONFIG)!;\n  }\n\n  private parseACLType(val: string | string[] | number | number[] | ACLType | null): ACLType {\n    let t: ACLType;\n    if (typeof val === 'number') {\n      t = { ability: [val] };\n    } else if (Array.isArray(val) && val.length > 0 && typeof val[0] === 'number') {\n      t = { ability: val };\n    } else if (typeof val === 'object' && !Array.isArray(val)) {\n      t = { ...val };\n    } else if (Array.isArray(val)) {\n      t = { role: val as string[] };\n    } else {\n      t = { role: val == null ? [] : [val] };\n    }\n\n    return { except: false, ...t };\n  }\n\n  /**\n   * 设置当前用户角色或权限能力（会先清除所有）\n   */\n  set(value: ACLType): void {\n    this.full = false;\n    this.abilities = [];\n    this.roles = [];\n    this.add(value);\n    this.aclChange.next(value);\n  }\n\n  /**\n   * 标识当前用户为全量，即不受限\n   */\n  setFull(val: boolean): void {\n    this.full = val;\n    this.aclChange.next(val);\n  }\n\n  /**\n   * 设置当前用户权限能力（会先清除所有）\n   */\n  setAbility(abilities: Array<number | string>): void {\n    this.set({ ability: abilities } as ACLType);\n  }\n\n  /**\n   * 设置当前用户角色（会先清除所有）\n   */\n  setRole(roles: string[]): void {\n    this.set({ role: roles } as ACLType);\n  }\n\n  /**\n   * 为当前用户增加角色或权限能力\n   */\n  add(value: ACLType): void {\n    if (value.role && value.role.length > 0) {\n      this.roles.push(...value.role);\n    }\n    if (value.ability && value.ability.length > 0) {\n      this.abilities.push(...value.ability);\n    }\n  }\n\n  /**\n   * 为当前用户附加角色\n   */\n  attachRole(roles: string[]): void {\n    for (const val of roles) {\n      if (!this.roles.includes(val)) {\n        this.roles.push(val);\n      }\n    }\n    this.aclChange.next(this.data);\n  }\n\n  /**\n   * 为当前用户附加权限\n   */\n  attachAbility(abilities: Array<number | string>): void {\n    for (const val of abilities) {\n      if (!this.abilities.includes(val)) {\n        this.abilities.push(val);\n      }\n    }\n    this.aclChange.next(this.data);\n  }\n\n  /**\n   * 为当前用户移除角色\n   */\n  removeRole(roles: string[]): void {\n    for (const val of roles) {\n      const idx = this.roles.indexOf(val);\n      if (idx !== -1) {\n        this.roles.splice(idx, 1);\n      }\n    }\n    this.aclChange.next(this.data);\n  }\n\n  /**\n   * 为当前用户移除权限\n   */\n  removeAbility(abilities: Array<number | string>): void {\n    for (const val of abilities) {\n      const idx = this.abilities.indexOf(val);\n      if (idx !== -1) {\n        this.abilities.splice(idx, 1);\n      }\n    }\n    this.aclChange.next(this.data);\n  }\n\n  /**\n   * 当前用户是否有对应角色，其实 `number` 表示Ability\n   *\n   * - 当 `full: true` 或参数 `null` 时返回 `true`\n   * - 若使用 `ACLType` 参数，可以指定 `mode` 校验模式\n   */\n  can(roleOrAbility: ACLCanType | null): boolean {\n    const { preCan } = this.options;\n    if (preCan) {\n      roleOrAbility = preCan(roleOrAbility!);\n    }\n\n    const t = this.parseACLType(roleOrAbility);\n    let result = false;\n    if (this.full === true || !roleOrAbility) {\n      result = true;\n    } else {\n      if (t.role && t.role.length > 0) {\n        if (t.mode === 'allOf') {\n          result = t.role.every(v => this.roles.includes(v));\n        } else {\n          result = t.role.some(v => this.roles.includes(v));\n        }\n      }\n      if (t.ability && t.ability.length > 0) {\n        if (t.mode === 'allOf') {\n          result = (t.ability as Array<number | string>).every(v => this.abilities.includes(v));\n        } else {\n          result = (t.ability as Array<number | string>).some(v => this.abilities.includes(v));\n        }\n      }\n    }\n\n    return t.except === true ? !result : result;\n  }\n\n  /** @inner */\n  parseAbility(value: ACLCanType): ACLCanType {\n    if (typeof value === 'number' || typeof value === 'string' || Array.isArray(value)) {\n      value = { ability: Array.isArray(value) ? value : [value] } as ACLType;\n    }\n    delete value.role;\n    return value;\n  }\n\n  /**\n   * 当前用户是否有对应权限点\n   */\n  canAbility(value: ACLCanType): boolean {\n    return this.can(this.parseAbility(value));\n  }\n}\n"]}

package/esm2015/src/acl.type.js

@@ -1,7 +1,7 @@
-/**
- * NOTE：`ACLType` 类型可能会被其他类库所引用，为了减少类库间彼此的依赖性，其他类库会以复制的形式存在
- * 当这里有变化时，请务必同步更新，涉及：`MenuService.acl`、`util.YunzaiACLType`
- * TODO: 尝试增加 `@yelon/core` 类库用于处理这种通用型
- */
-export {};
+/**
+ * NOTE：`ACLType` 类型可能会被其他类库所引用，为了减少类库间彼此的依赖性，其他类库会以复制的形式存在
+ * 当这里有变化时，请务必同步更新，涉及：`MenuService.acl`、`util.YunzaiACLType`
+ * TODO: 尝试增加 `@yelon/core` 类库用于处理这种通用型
+ */
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNsLnR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hY2wvc3JjL2FjbC50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIE5PVEXvvJpgQUNMVHlwZWAg57G75Z6L5Y+v6IO95Lya6KKr5YW25LuW57G75bqT5omA5byV55So77yM5Li65LqG5YeP5bCR57G75bqT6Ze05b285q2k55qE5L6d6LWW5oCn77yM5YW25LuW57G75bqT5Lya5Lul5aSN5Yi255qE5b2i5byP5a2Y5ZyoXG4gKiDlvZPov5nph4zmnInlj5jljJbml7bvvIzor7fliqHlv4XlkIzmraXmm7TmlrDvvIzmtonlj4rvvJpgTWVudVNlcnZpY2UuYWNsYOOAgWB1dGlsLll1bnphaUFDTFR5cGVgXG4gKiBUT0RPOiDlsJ3or5Xlop7liqAgYEB5ZWxvbi9jb3JlYCDnsbvlupPnlKjkuo7lpITnkIbov5nnp43pgJrnlKjlnotcbiAqL1xuXG5pbXBvcnQgeyBJbmplY3RvciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuXG5pbXBvcnQgdHlwZSB7IE56U2FmZUFueSB9IGZyb20gJ25nLXpvcnJvLWFudGQvY29yZS90eXBlcyc7XG5cbmltcG9ydCB7IEFDTFNlcnZpY2UgfSBmcm9tICcuL2FjbC5zZXJ2aWNlJztcblxuZXhwb3J0IGludGVyZmFjZSBBQ0xUeXBlIHtcbiAgLyoqXG4gICAqIOinkuiJslxuICAgKi9cbiAgcm9sZT86IHN0cmluZ1tdO1xuICAvKipcbiAgICog5p2D6ZmQ54K5XG4gICAqL1xuICBhYmlsaXR5PzogbnVtYmVyW10gfCBzdHJpbmdbXTtcblxuICAvKipcbiAgICogVmFsaWRhdGVkIGFnYWluc3QsIGRlZmF1bHQ6IGBvbmVPZmBcbiAgICogLSBgYWxsT2ZgIHRoZSB2YWx1ZSB2YWxpZGF0ZXMgYWdhaW5zdCBhbGwgdGhlIHJvbGVzIG9yIGFiaWxpdGllc1xuICAgKiAtIGBvbmVPZmAgdGhlIHZhbHVlIHZhbGlkYXRlcyBhZ2FpbnN0IGV4YWN0bHkgb25lIG9mIHRoZSByb2xlcyBvciBhYmlsaXRpZXNcbiAgICovXG4gIG1vZGU/OiAnYWxsT2YnIHwgJ29uZU9mJztcblxuICAvKipcbiAgICog5piv5ZCm5Y+W5Y+N77yM5Y2z57uT5p6c5Li6IGB0cnVlYCDml7booajnpLrmnKrmjojmnYNcbiAgICovXG4gIGV4Y2VwdD86IGJvb2xlYW47XG5cbiAgW2tleTogc3RyaW5nXTogTnpTYWZlQW55O1xufVxuXG5leHBvcnQgdHlwZSBBQ0xDYW5UeXBlID0gbnVtYmVyIHwgbnVtYmVyW10gfCBzdHJpbmcgfCBzdHJpbmdbXSB8IEFDTFR5cGU7XG5leHBvcnQgdHlwZSBBQ0xHdWFyZEZ1bmN0aW9uVHlwZSA9IChzcnY6IEFDTFNlcnZpY2UsIGluamVjdG9yOiBJbmplY3RvcikgPT4gT2JzZXJ2YWJsZTxBQ0xDYW5UeXBlPjtcbmV4cG9ydCB0eXBlIEFDTEd1YXJkVHlwZSA9IEFDTENhblR5cGUgfCBPYnNlcnZhYmxlPEFDTENhblR5cGU+IHwgQUNMR3VhcmRGdW5jdGlvblR5cGU7XG4iXX0=