@yelon/acl 15.2.6 → 16.0.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2017-present yunzai<devcui@outlook.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2017-present yunzai<devcui@outlook.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,23 +1,23 @@
-# @yelon/acl [![Build Status](https://dev.azure.com/ng-yunzai/yelon/_apis/build/status/yelon-CI?branchName=master)](https://dev.azure.com/ng-yunzai/yelon/_build/latest?definitionId=1&branchName=master) [![NPM version](https://img.shields.io/npm/v/@yelon/acl.svg?style=flat-square)](https://www.npmjs.com/package/@yelon/acl)
-
-A simple role-based access control.
-
-## Links
-
-+ [Document](https://ng.yunzainfo.com/acl) ([Surge Mirror](https://ng-yunzai-doc.surge.sh/acl)
-+ [@yelon Source](https://github.com/hbyunzai/yelon)
-+ [DEMO](https://ng-yunzai.surge.sh) ([国内镜像](https://ng-yunzai.gitee.io/))
-
-
-## Troubleshooting
-
-Please follow this guidelines when reporting bugs and feature requests:
-
-1. Use [GitHub Issues](https://github.com/hbyunzai/yelon/issues) board to report bugs and feature requests (not our email address)
-2. Please **always** write steps to reproduce the error. That way we can focus on fixing the bug, not scratching our heads trying to reproduce it.
-
-Thanks for understanding!
-
-### License
-
-The MIT License (see the [LICENSE](https://github.com/hbyunzai/yelon/blob/master/LICENSE) file for the full text)
+# @yelon/acl [![Build Status](https://dev.azure.com/ng-yunzai/yelon/_apis/build/status/yelon-CI?branchName=master)](https://dev.azure.com/ng-yunzai/yelon/_build/latest?definitionId=1&branchName=master) [![NPM version](https://img.shields.io/npm/v/@yelon/acl.svg?style=flat-square)](https://www.npmjs.com/package/@yelon/acl)
+
+A simple role-based access control.
+
+## Links
+
++ [Document](https://ng.yunzainfo.com/acl) ([Surge Mirror](https://ng-yunzai-doc.surge.sh/acl)
++ [@yelon Source](https://github.com/hbyunzai/yelon)
++ [DEMO](https://ng-yunzai.surge.sh) ([国内镜像](https://ng-yunzai.gitee.io/))
+
+
+## Troubleshooting
+
+Please follow this guidelines when reporting bugs and feature requests:
+
+1. Use [GitHub Issues](https://github.com/hbyunzai/yelon/issues) board to report bugs and feature requests (not our email address)
+2. Please **always** write steps to reproduce the error. That way we can focus on fixing the bug, not scratching our heads trying to reproduce it.
+
+Thanks for understanding!
+
+### License
+
+The MIT License (see the [LICENSE](https://github.com/hbyunzai/yelon/blob/master/LICENSE) file for the full text)

package/{esm2020 → esm2022}/acl.mjs

@@ -1,5 +1,5 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './index';
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvYWNsL2FjbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/{esm2020 → esm2022}/index.mjs

@@ -1,8 +1,8 @@
-export * from './src/acl.service';
-export * from './src/acl-if.directive';
-export * from './src/acl.directive';
-export * from './src/acl.config';
-export * from './src/acl.type';
-export * from './src/acl-guard';
-export * from './src/acl.module';
+export * from './src/acl.service';
+export * from './src/acl-if.directive';
+export * from './src/acl.directive';
+export * from './src/acl.config';
+export * from './src/acl.type';
+export * from './src/acl-guard';
+export * from './src/acl.module';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9hY2wvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc3JjL2FjbC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL2FjbC1pZi5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvYWNsLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9hY2wuY29uZmlnJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL2FjbC50eXBlJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL2FjbC1ndWFyZCc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9hY2wubW9kdWxlJztcbiJdfQ==

package/esm2022/src/acl-guard.mjs

@@ -0,0 +1,58 @@
+import { Injectable } from '@angular/core';
+import { Observable, of, map, tap } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./acl.service";
+import * as i2 from "@angular/router";
+/**
+ * Routing guard prevent unauthorized users visit the page, [ACL Document](https://ng.yunzainfo.com/acl).
+ *
+ * ```ts
+ * data: {
+ *  path: 'home',
+ *  canActivate: [ ACLGuard ],
+ *  data: { guard: 'user1' }
+ * }
+ * ```
+ */
+class ACLGuard {
+    constructor(srv, router, injector) {
+        this.srv = srv;
+        this.router = router;
+        this.injector = injector;
+    }
+    process(data) {
+        data = {
+            guard: null,
+            guard_url: this.srv.guard_url,
+            ...data
+        };
+        let guard = data.guard;
+        if (typeof guard === 'function')
+            guard = guard(this.srv, this.injector);
+        return (guard && guard instanceof Observable ? guard : of(guard != null ? guard : null)).pipe(map(v => this.srv.can(v)), tap(v => {
+            if (v)
+                return;
+            this.router.navigateByUrl(data.guard_url);
+        }));
+    }
+    // lazy loading
+    canMatch(route) {
+        return this.process(route.data);
+    }
+    // all children route
+    canActivateChild(childRoute, state) {
+        return this.canActivate(childRoute, state);
+    }
+    // route
+    canActivate(route, _state) {
+        return this.process(route.data);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: ACLGuard, deps: [{ token: i1.ACLService }, { token: i2.Router }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: ACLGuard, providedIn: 'root' }); }
+}
+export { ACLGuard };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: ACLGuard, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.ACLService }, { type: i2.Router }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/acl-if.directive.mjs

@@ -0,0 +1,80 @@
+import { Directive, Input } from '@angular/core';
+import { filter } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./acl.service";
+class ACLIfDirective {
+    constructor(templateRef, srv, _viewContainer) {
+        this.srv = srv;
+        this._viewContainer = _viewContainer;
+        this._thenTemplateRef = null;
+        this._elseTemplateRef = null;
+        this._thenViewRef = null;
+        this._elseViewRef = null;
+        this._except = false;
+        this._change$ = this.srv.change.pipe(filter(r => r != null)).subscribe(() => this._updateView());
+        this._thenTemplateRef = templateRef;
+    }
+    set aclIf(value) {
+        this._value = value;
+        this._updateView();
+    }
+    set aclIfThen(templateRef) {
+        this._thenTemplateRef = templateRef;
+        this._thenViewRef = null;
+        this._updateView();
+    }
+    set aclIfElse(templateRef) {
+        this._elseTemplateRef = templateRef;
+        this._elseViewRef = null;
+        this._updateView();
+    }
+    set except(value) {
+        this._except = value != null && `${value}` !== 'false';
+    }
+    get except() {
+        return this._except;
+    }
+    _updateView() {
+        const res = this.srv.can(this._value);
+        if ((res && !this.except) || (!res && this.except)) {
+            if (!this._thenViewRef) {
+                this._viewContainer.clear();
+                this._elseViewRef = null;
+                if (this._thenTemplateRef) {
+                    this._thenViewRef = this._viewContainer.createEmbeddedView(this._thenTemplateRef);
+                }
+            }
+        }
+        else {
+            if (!this._elseViewRef) {
+                this._viewContainer.clear();
+                this._thenViewRef = null;
+                if (this._elseTemplateRef) {
+                    this._elseViewRef = this._viewContainer.createEmbeddedView(this._elseTemplateRef);
+                }
+            }
+        }
+    }
+    ngOnDestroy() {
+        this._change$.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: ACLIfDirective, deps: [{ token: i0.TemplateRef }, { token: i1.ACLService }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.2", type: ACLIfDirective, selector: "[aclIf]", inputs: { aclIf: "aclIf", aclIfThen: "aclIfThen", aclIfElse: "aclIfElse", except: "except" }, exportAs: ["aclIf"], ngImport: i0 }); }
+}
+export { ACLIfDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: ACLIfDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[aclIf]',
+                    exportAs: 'aclIf'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i1.ACLService }, { type: i0.ViewContainerRef }]; }, propDecorators: { aclIf: [{
+                type: Input
+            }], aclIfThen: [{
+                type: Input
+            }], aclIfElse: [{
+                type: Input
+            }], except: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/src/acl.config.mjs

@@ -1,4 +1,4 @@
-export const ACL_DEFAULT_CONFIG = {
-    guard_url: `/403`
-};
+export const ACL_DEFAULT_CONFIG = {
+    guard_url: `/403`
+};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNsLmNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2FjbC9zcmMvYWNsLmNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBb0I7SUFDakQsU0FBUyxFQUFFLE1BQU07Q0FDbEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgWXVuemFpQUNMQ29uZmlnIH0gZnJvbSAnQHllbG9uL3V0aWwvY29uZmlnJztcblxuZXhwb3J0IGNvbnN0IEFDTF9ERUZBVUxUX0NPTkZJRzogWXVuemFpQUNMQ29uZmlnID0ge1xuICBndWFyZF91cmw6IGAvNDAzYFxufTtcbiJdfQ==

package/esm2022/src/acl.directive.mjs

@@ -0,0 +1,49 @@
+import { Directive, Input } from '@angular/core';
+import { filter } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./acl.service";
+class ACLDirective {
+    set acl(value) {
+        this.set(value);
+    }
+    set ability(value) {
+        this.set(this.srv.parseAbility(value));
+    }
+    set(value) {
+        this._value = value;
+        const CLS = 'acl__hide';
+        const el = this.el.nativeElement;
+        if (this.srv.can(this._value)) {
+            this.renderer.removeClass(el, CLS);
+        }
+        else {
+            this.renderer.addClass(el, CLS);
+        }
+    }
+    constructor(el, renderer, srv) {
+        this.el = el;
+        this.renderer = renderer;
+        this.srv = srv;
+        this.change$ = this.srv.change.pipe(filter(r => r != null)).subscribe(() => this.set(this._value));
+    }
+    ngOnDestroy() {
+        this.change$.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: ACLDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.ACLService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.2", type: ACLDirective, selector: "[acl]", inputs: { acl: "acl", ability: ["acl-ability", "ability"] }, exportAs: ["acl"], ngImport: i0 }); }
+}
+export { ACLDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: ACLDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[acl]',
+                    exportAs: 'acl'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.ACLService }]; }, propDecorators: { acl: [{
+                type: Input,
+                args: ['acl']
+            }], ability: [{
+                type: Input,
+                args: ['acl-ability']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/acl.module.mjs

@@ -0,0 +1,28 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ACLIfDirective } from './acl-if.directive';
+import { ACLDirective } from './acl.directive';
+import { ACLService } from './acl.service';
+import * as i0 from "@angular/core";
+const COMPONENTS = [ACLDirective, ACLIfDirective];
+class YelonACLModule {
+    static forRoot() {
+        return {
+            ngModule: YelonACLModule,
+            providers: [ACLService]
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: YelonACLModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.2", ngImport: i0, type: YelonACLModule, declarations: [ACLDirective, ACLIfDirective], imports: [CommonModule], exports: [ACLDirective, ACLIfDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: YelonACLModule, imports: [CommonModule] }); }
+}
+export { YelonACLModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: YelonACLModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: COMPONENTS,
+                    exports: COMPONENTS
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNsLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2FjbC9zcmMvYWNsLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUF1QixRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFOUQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3BELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUUzQyxNQUFNLFVBQVUsR0FBRyxDQUFDLFlBQVksRUFBRSxjQUFjLENBQUMsQ0FBQztBQUVsRCxNQUthLGNBQWM7SUFDekIsTUFBTSxDQUFDLE9BQU87UUFDWixPQUFPO1lBQ0wsUUFBUSxFQUFFLGNBQWM7WUFDeEIsU0FBUyxFQUFFLENBQUMsVUFBVSxDQUFDO1NBQ3hCLENBQUM7SUFDSixDQUFDOzhHQU5VLGNBQWM7K0dBQWQsY0FBYyxpQkFQUCxZQUFZLEVBQUUsY0FBYyxhQUdwQyxZQUFZLGFBSEosWUFBWSxFQUFFLGNBQWM7K0dBT25DLGNBQWMsWUFKZixZQUFZOztTQUlYLGNBQWM7MkZBQWQsY0FBYztrQkFMMUIsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQyxZQUFZLENBQUM7b0JBQ3ZCLFlBQVksRUFBRSxVQUFVO29CQUN4QixPQUFPLEVBQUUsVUFBVTtpQkFDcEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTW9kdWxlV2l0aFByb3ZpZGVycywgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgQUNMSWZEaXJlY3RpdmUgfSBmcm9tICcuL2FjbC1pZi5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgQUNMRGlyZWN0aXZlIH0gZnJvbSAnLi9hY2wuZGlyZWN0aXZlJztcbmltcG9ydCB7IEFDTFNlcnZpY2UgfSBmcm9tICcuL2FjbC5zZXJ2aWNlJztcblxuY29uc3QgQ09NUE9ORU5UUyA9IFtBQ0xEaXJlY3RpdmUsIEFDTElmRGlyZWN0aXZlXTtcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gIGRlY2xhcmF0aW9uczogQ09NUE9ORU5UUyxcbiAgZXhwb3J0czogQ09NUE9ORU5UU1xufSlcbmV4cG9ydCBjbGFzcyBZZWxvbkFDTE1vZHVsZSB7XG4gIHN0YXRpYyBmb3JSb290KCk6IE1vZHVsZVdpdGhQcm92aWRlcnM8WWVsb25BQ0xNb2R1bGU+IHtcbiAgICByZXR1cm4ge1xuICAgICAgbmdNb2R1bGU6IFllbG9uQUNMTW9kdWxlLFxuICAgICAgcHJvdmlkZXJzOiBbQUNMU2VydmljZV1cbiAgICB9O1xuICB9XG59XG4iXX0=

package/esm2022/src/acl.service.mjs

@@ -0,0 +1,196 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ACL_DEFAULT_CONFIG } from './acl.config';
+import * as i0 from "@angular/core";
+import * as i1 from "@yelon/util/config";
+/**
+ * ACL 控制服务，[在线文档](https://ng.yunzainfo.com/acl)
+ *
+ * 务必在根目录注册 `YelonACLModule.forRoot()` 才能使用服务
+ */
+class ACLService {
+    /** 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;
+    }
+    constructor(configSrv) {
+        this.roles = [];
+        this.abilities = [];
+        this.full = false;
+        this.aclChange = new BehaviorSubject(null);
+        this.options = configSrv.merge('acl', ACL_DEFAULT_CONFIG);
+    }
+    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 = { ...val };
+        }
+        else if (Array.isArray(val)) {
+            t = { role: val };
+        }
+        else {
+            t = { role: val == null ? [] : [val] };
+        }
+        return { 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));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: ACLService, deps: [{ token: i1.YunzaiConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: ACLService }); }
+}
+export { ACLService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: ACLService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.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/{esm2020 → esm2022}/src/acl.type.mjs

@@ -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+v6IO95Lya6KKr5YW25LuW57G75bqT5omA5byV55So77yM5Li65LqG5YeP5bCR57G75bqT6Ze05b285q2k55qE5L6d6LWW5oCn77yM5YW25LuW57G75bqT5Lya5Lul5aSN5Yi255qE5b2i5byP5a2Y5ZyoXG4gKiDlvZPov5nph4zmnInlj5jljJbml7bvvIzor7fliqHlv4XlkIzmraXmm7TmlrDvvIzmtonlj4rvvJpgTWVudVNlcnZpY2UuYWNsYOOAgWB1dGlsLll1bnphaUFDTFR5cGVgXG4gKiBUT0RPOiDlsJ3or5Xlop7liqAgYEB5ZWxvbi9jb3JlYCDnsbvlupPnlKjkuo7lpITnkIbov5nnp43pgJrnlKjlnotcbiAqL1xuXG5pbXBvcnQgeyBJbmplY3RvciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuXG5pbXBvcnQgdHlwZSB7IEFDTFNlcnZpY2UgfSBmcm9tICcuL2FjbC5zZXJ2aWNlJztcblxuZXhwb3J0IGludGVyZmFjZSBBQ0xUeXBlIHtcbiAgLyoqXG4gICAqIOinkuiJslxuICAgKi9cbiAgcm9sZT86IHN0cmluZ1tdO1xuICAvKipcbiAgICog5p2D6ZmQ54K5XG4gICAqL1xuICBhYmlsaXR5PzogbnVtYmVyW10gfCBzdHJpbmdbXTtcblxuICAvKipcbiAgICogVmFsaWRhdGVkIGFnYWluc3QsIGRlZmF1bHQ6IGBvbmVPZmBcbiAgICogLSBgYWxsT2ZgIHRoZSB2YWx1ZSB2YWxpZGF0ZXMgYWdhaW5zdCBhbGwgdGhlIHJvbGVzIG9yIGFiaWxpdGllc1xuICAgKiAtIGBvbmVPZmAgdGhlIHZhbHVlIHZhbGlkYXRlcyBhZ2FpbnN0IGV4YWN0bHkgb25lIG9mIHRoZSByb2xlcyBvciBhYmlsaXRpZXNcbiAgICovXG4gIG1vZGU/OiAnYWxsT2YnIHwgJ29uZU9mJztcblxuICAvKipcbiAgICog5piv5ZCm5Y+W5Y+N77yM5Y2z57uT5p6c5Li6IGB0cnVlYCDml7booajnpLrmnKrmjojmnYNcbiAgICovXG4gIGV4Y2VwdD86IGJvb2xlYW47XG5cbiAgW2tleTogc3RyaW5nXTogYW55O1xufVxuXG5leHBvcnQgdHlwZSBBQ0xDYW5UeXBlID0gbnVtYmVyIHwgbnVtYmVyW10gfCBzdHJpbmcgfCBzdHJpbmdbXSB8IEFDTFR5cGU7XG5cbmV4cG9ydCB0eXBlIEFDTEd1YXJkRnVuY3Rpb25UeXBlID0gKHNydjogQUNMU2VydmljZSwgaW5qZWN0b3I6IEluamVjdG9yKSA9PiBPYnNlcnZhYmxlPEFDTENhblR5cGU+O1xuZXhwb3J0IHR5cGUgQUNMR3VhcmRUeXBlID0gQUNMQ2FuVHlwZSB8IE9ic2VydmFibGU8QUNMQ2FuVHlwZT4gfCBBQ0xHdWFyZEZ1bmN0aW9uVHlwZTtcbiJdfQ==