@delon/auth 12.4.2 → 13.1.0

package/auth.d.ts

@@ -1,4 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
+/// <amd-module name="@delon/auth" />
 export * from './index';

package/esm2020/src/auth.module.mjs

@@ -0,0 +1,12 @@
+import { NgModule } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DelonAuthModule {
+}
+DelonAuthModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: DelonAuthModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DelonAuthModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: DelonAuthModule });
+DelonAuthModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: DelonAuthModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: DelonAuthModule, decorators: [{
+            type: NgModule,
+            args: [{}]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hdXRoL3NyYy9hdXRoLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUd6QyxNQUFNLE9BQU8sZUFBZTs7NEdBQWYsZUFBZTs2R0FBZixlQUFlOzZHQUFmLGVBQWU7MkZBQWYsZUFBZTtrQkFEM0IsUUFBUTttQkFBQyxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQE5nTW9kdWxlKHt9KVxuZXhwb3J0IGNsYXNzIERlbG9uQXV0aE1vZHVsZSB7fVxuIl19

package/esm2020/src/social/social.service.mjs

@@ -0,0 +1,105 @@
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { DA_SERVICE_TOKEN } from '../token/interface';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+const OPENTYPE = '_delonAuthSocialType';
+const HREFCALLBACK = '_delonAuthSocialCallbackByHref';
+export class SocialService {
+    constructor(tokenService, doc, router) {
+        this.tokenService = tokenService;
+        this.doc = doc;
+        this.router = router;
+        this._win = null;
+    }
+    /**
+     * 跳转至登录页，若为 `type=window` 时，返回值是 `Observable<ITokenModel>`
+     *
+     * @param url 获取授权地址
+     * @param callback 当 `type=href` 成功时的回调路由地址
+     * @param options.type 打开方式，默认 `window`
+     * @param options.windowFeatures 等同 `window.open` 的 `features` 参数值
+     */
+    login(url, callback = '/', options = {}) {
+        options = {
+            type: 'window',
+            windowFeatures: 'location=yes,height=570,width=520,scrollbars=yes,status=yes',
+            ...options
+        };
+        localStorage.setItem(OPENTYPE, options.type);
+        localStorage.setItem(HREFCALLBACK, callback);
+        if (options.type === 'href') {
+            this.doc.location.href = url;
+            return;
+        }
+        this._win = window.open(url, '_blank', options.windowFeatures);
+        this._winTime = setInterval(() => {
+            if (this._win && this._win.closed) {
+                this.ngOnDestroy();
+                let model = this.tokenService.get();
+                if (model && !model.token)
+                    model = null;
+                // 触发变更通知
+                if (model) {
+                    this.tokenService.set(model);
+                }
+                this.observer.next(model);
+                this.observer.complete();
+            }
+        }, 100);
+        return new Observable((observer) => {
+            this.observer = observer;
+        });
+    }
+    /**
+     * 授权成功后的回调处理
+     *
+     * @param rawData 指定回调认证信息，为空时从根据当前URL解析
+     */
+    callback(rawData) {
+        // from uri
+        if (!rawData && this.router.url.indexOf('?') === -1) {
+            throw new Error(`url muse contain a ?`);
+        }
+        // parse
+        let data = { token: `` };
+        if (typeof rawData === 'string') {
+            const rightUrl = rawData.split('?')[1].split('#')[0];
+            data = this.router.parseUrl(`./?${rightUrl}`).queryParams;
+        }
+        else {
+            data = rawData;
+        }
+        if (!data || !data.token)
+            throw new Error(`invalide token data`);
+        this.tokenService.set(data);
+        const url = localStorage.getItem(HREFCALLBACK) || '/';
+        localStorage.removeItem(HREFCALLBACK);
+        const type = localStorage.getItem(OPENTYPE);
+        localStorage.removeItem(OPENTYPE);
+        if (type === 'window') {
+            window.close();
+        }
+        else {
+            this.router.navigateByUrl(url);
+        }
+        return data;
+    }
+    ngOnDestroy() {
+        clearInterval(this._winTime);
+        this._winTime = null;
+    }
+}
+SocialService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: SocialService, deps: [{ token: DA_SERVICE_TOKEN }, { token: DOCUMENT }, { token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+SocialService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: SocialService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: SocialService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DA_SERVICE_TOKEN]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"social.service.js","sourceRoot":"","sources":["../../../../../../packages/auth/src/social/social.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport { Inject, Injectable, OnDestroy } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { Observable, Observer } from 'rxjs';\n\nimport type { NzSafeAny } from 'ng-zorro-antd/core/types';\n\nimport { DA_SERVICE_TOKEN, ITokenModel, ITokenService } from '../token/interface';\n\nconst OPENTYPE = '_delonAuthSocialType';\nconst HREFCALLBACK = '_delonAuthSocialCallbackByHref';\n\nexport type SocialOpenType = 'href' | 'window';\n\n@Injectable()\nexport class SocialService implements OnDestroy {\n  private _win: Window | null = null;\n  private _winTime: NzSafeAny;\n  private observer!: Observer<ITokenModel | null>;\n\n  constructor(\n    @Inject(DA_SERVICE_TOKEN) private tokenService: ITokenService,\n    @Inject(DOCUMENT) private doc: NzSafeAny,\n    private router: Router\n  ) {}\n\n  /**\n   * 使用窗体打开授权页，返回值是 `Observable<ITokenModel>` 用于订阅授权后返回的结果\n   *\n   * @param url 获取授权地址\n   * @param callback 回调路由地址\n   * @param options.windowFeatures 等同 `window.open` 的 `features` 参数值\n   */\n  login(\n    url: string,\n    callback?: string,\n    options?: {\n      type?: 'window';\n      windowFeatures?: string;\n    }\n  ): Observable<ITokenModel>;\n\n  /**\n   * 跳转至授权页\n   *\n   * @param url 获取授权地址\n   * @param callback 回调路由地址\n   */\n  login(\n    url: string,\n    callback?: string,\n    options?: {\n      type?: 'href';\n    }\n  ): void;\n\n  /**\n   * 跳转至登录页，若为 `type=window` 时，返回值是 `Observable<ITokenModel>`\n   *\n   * @param url 获取授权地址\n   * @param callback 当 `type=href` 成功时的回调路由地址\n   * @param options.type 打开方式，默认 `window`\n   * @param options.windowFeatures 等同 `window.open` 的 `features` 参数值\n   */\n  login(\n    url: string,\n    callback: string = '/',\n    options: {\n      type?: SocialOpenType;\n      windowFeatures?: string;\n    } = {}\n  ): Observable<ITokenModel | null> | void {\n    options = {\n      type: 'window',\n      windowFeatures: 'location=yes,height=570,width=520,scrollbars=yes,status=yes',\n      ...options\n    };\n    localStorage.setItem(OPENTYPE, options.type!);\n    localStorage.setItem(HREFCALLBACK, callback);\n    if (options.type === 'href') {\n      this.doc.location.href = url;\n      return;\n    }\n\n    this._win = window.open(url, '_blank', options.windowFeatures);\n    this._winTime = setInterval(() => {\n      if (this._win && this._win.closed) {\n        this.ngOnDestroy();\n\n        let model = this.tokenService.get();\n        if (model && !model.token) model = null;\n\n        // 触发变更通知\n        if (model) {\n          this.tokenService.set(model);\n        }\n\n        this.observer.next(model);\n        this.observer.complete();\n      }\n    }, 100);\n    return new Observable((observer: Observer<ITokenModel | null>) => {\n      this.observer = observer;\n    });\n  }\n\n  /**\n   * 授权成功后的回调处理\n   *\n   * @param rawData 指定回调认证信息，为空时从根据当前URL解析\n   */\n  callback(rawData?: ITokenModel | string | null): ITokenModel {\n    // from uri\n    if (!rawData && this.router.url.indexOf('?') === -1) {\n      throw new Error(`url muse contain a ?`);\n    }\n    // parse\n    let data: ITokenModel = { token: `` };\n    if (typeof rawData === 'string') {\n      const rightUrl = rawData.split('?')[1].split('#')[0];\n      data = this.router.parseUrl(`./?${rightUrl}`).queryParams as ITokenModel;\n    } else {\n      data = rawData as ITokenModel;\n    }\n\n    if (!data || !data.token) throw new Error(`invalide token data`);\n    this.tokenService.set(data);\n\n    const url = localStorage.getItem(HREFCALLBACK) || '/';\n    localStorage.removeItem(HREFCALLBACK);\n    const type = localStorage.getItem(OPENTYPE);\n    localStorage.removeItem(OPENTYPE);\n    if (type === 'window') {\n      window.close();\n    } else {\n      this.router.navigateByUrl(url);\n    }\n\n    return data;\n  }\n\n  ngOnDestroy(): void {\n    clearInterval(this._winTime);\n    this._winTime = null;\n  }\n}\n"]}

package/esm2020/src/token/base.interceptor.mjs

@@ -0,0 +1,86 @@
+import { HttpErrorResponse, HttpParams, HTTP_INTERCEPTORS } from '@angular/common/http';
+import { Injectable, Optional } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AlainConfigService } from '@delon/util/config';
+import { mergeConfig } from '../auth.config';
+import { ToLogin } from './helper';
+import * as i0 from "@angular/core";
+class HttpAuthInterceptorHandler {
+    constructor(next, interceptor) {
+        this.next = next;
+        this.interceptor = interceptor;
+    }
+    handle(req) {
+        return this.interceptor.intercept(req, this.next);
+    }
+}
+export class BaseInterceptor {
+    constructor(injector) {
+        this.injector = injector;
+    }
+    intercept(req, next) {
+        const options = mergeConfig(this.injector.get(AlainConfigService));
+        if (Array.isArray(options.ignores)) {
+            for (const item of options.ignores) {
+                if (item.test(req.url))
+                    return next.handle(req);
+            }
+        }
+        const ingoreKey = options.allow_anonymous_key;
+        let ingored = false;
+        let params = req.params;
+        let url = req.url;
+        if (req.params.has(ingoreKey)) {
+            params = req.params.delete(ingoreKey);
+            ingored = true;
+        }
+        const urlArr = req.url.split('?');
+        if (urlArr.length > 1) {
+            const queryStringParams = new HttpParams({ fromString: urlArr[1] });
+            if (queryStringParams.has(ingoreKey)) {
+                const queryString = queryStringParams.delete(ingoreKey).toString();
+                url = queryString.length > 0 ? `${urlArr[0]}?${queryString}` : urlArr[0];
+                ingored = true;
+            }
+        }
+        if (ingored) {
+            return next.handle(req.clone({ params, url }));
+        }
+        if (this.isAuth(options)) {
+            req = this.setReq(req, options);
+        }
+        else {
+            ToLogin(options, this.injector);
+            // Interrupt Http request, so need to generate a new Observable
+            const err$ = new Observable((observer) => {
+                const res = new HttpErrorResponse({
+                    url: req.url,
+                    headers: req.headers,
+                    status: 401,
+                    statusText: `来自 @delon/auth 的拦截，所请求URL未授权，若是登录API可加入 [url?_allow_anonymous=true] 来表示忽略校验，更多方法请参考： https://ng-alain.com/auth/getting-started#AlainAuthConfig\nThe interception from @delon/auth, the requested URL is not authorized. If the login API can add [url?_allow_anonymous=true] to ignore the check, please refer to: https://ng-alain.com/auth/getting-started#AlainAuthConfig`
+                });
+                observer.error(res);
+            });
+            if (options.executeOtherInterceptors) {
+                const interceptors = this.injector.get(HTTP_INTERCEPTORS, []);
+                const lastInterceptors = interceptors.slice(interceptors.indexOf(this) + 1);
+                if (lastInterceptors.length > 0) {
+                    const chain = lastInterceptors.reduceRight((_next, _interceptor) => new HttpAuthInterceptorHandler(_next, _interceptor), {
+                        handle: (_) => err$
+                    });
+                    return chain.handle(req);
+                }
+            }
+            return err$;
+        }
+        return next.handle(req);
+    }
+}
+BaseInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: BaseInterceptor, deps: [{ token: i0.Injector, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+BaseInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: BaseInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: BaseInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.interceptor.js","sourceRoot":"","sources":["../../../../../../packages/auth/src/token/base.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  HttpErrorResponse,\n  HttpEvent,\n  HttpHandler,\n  HttpInterceptor,\n  HttpParams,\n  HttpRequest,\n  HTTP_INTERCEPTORS\n} from '@angular/common/http';\nimport { Injectable, Injector, Optional } from '@angular/core';\nimport { Observable, Observer } from 'rxjs';\n\nimport { AlainAuthConfig, AlainConfigService } from '@delon/util/config';\nimport type { NzSafeAny } from 'ng-zorro-antd/core/types';\n\nimport { mergeConfig } from '../auth.config';\nimport { ToLogin } from './helper';\nimport { ITokenModel } from './interface';\n\nclass HttpAuthInterceptorHandler implements HttpHandler {\n  constructor(private next: HttpHandler, private interceptor: HttpInterceptor) {}\n\n  handle(req: HttpRequest<NzSafeAny>): Observable<HttpEvent<NzSafeAny>> {\n    return this.interceptor.intercept(req, this.next);\n  }\n}\n\n@Injectable()\nexport abstract class BaseInterceptor implements HttpInterceptor {\n  constructor(@Optional() protected injector: Injector) {}\n\n  protected model!: ITokenModel;\n\n  abstract isAuth(options: AlainAuthConfig): boolean;\n\n  abstract setReq(req: HttpRequest<NzSafeAny>, options: AlainAuthConfig): HttpRequest<NzSafeAny>;\n\n  intercept(req: HttpRequest<NzSafeAny>, next: HttpHandler): Observable<HttpEvent<NzSafeAny>> {\n    const options = mergeConfig(this.injector.get(AlainConfigService));\n    if (Array.isArray(options.ignores)) {\n      for (const item of options.ignores) {\n        if (item.test(req.url)) return next.handle(req);\n      }\n    }\n\n    const ingoreKey = options.allow_anonymous_key!;\n    let ingored = false;\n    let params = req.params;\n    let url = req.url;\n    if (req.params.has(ingoreKey)) {\n      params = req.params.delete(ingoreKey);\n      ingored = true;\n    }\n    const urlArr = req.url.split('?');\n    if (urlArr.length > 1) {\n      const queryStringParams = new HttpParams({ fromString: urlArr[1] });\n      if (queryStringParams.has(ingoreKey)) {\n        const queryString = queryStringParams.delete(ingoreKey).toString();\n        url = queryString.length > 0 ? `${urlArr[0]}?${queryString}` : urlArr[0];\n        ingored = true;\n      }\n    }\n    if (ingored) {\n      return next.handle(req.clone({ params, url }));\n    }\n\n    if (this.isAuth(options)) {\n      req = this.setReq(req, options);\n    } else {\n      ToLogin(options, this.injector);\n      // Interrupt Http request, so need to generate a new Observable\n      const err$ = new Observable((observer: Observer<HttpEvent<NzSafeAny>>) => {\n        const res = new HttpErrorResponse({\n          url: req.url,\n          headers: req.headers,\n          status: 401,\n          statusText: `来自 @delon/auth 的拦截，所请求URL未授权，若是登录API可加入 [url?_allow_anonymous=true] 来表示忽略校验，更多方法请参考： https://ng-alain.com/auth/getting-started#AlainAuthConfig\\nThe interception from @delon/auth, the requested URL is not authorized. If the login API can add [url?_allow_anonymous=true] to ignore the check, please refer to: https://ng-alain.com/auth/getting-started#AlainAuthConfig`\n        });\n        observer.error(res);\n      });\n      if (options.executeOtherInterceptors) {\n        const interceptors = this.injector.get(HTTP_INTERCEPTORS, []);\n        const lastInterceptors = interceptors.slice(interceptors.indexOf(this) + 1);\n        if (lastInterceptors.length > 0) {\n          const chain = lastInterceptors.reduceRight(\n            (_next, _interceptor) => new HttpAuthInterceptorHandler(_next, _interceptor),\n            {\n              handle: (_: HttpRequest<NzSafeAny>) => err$\n            }\n          );\n          return chain.handle(req);\n        }\n      }\n      return err$;\n    }\n    return next.handle(req);\n  }\n}\n"]}

package/esm2020/src/token/helper.mjs

@@ -0,0 +1,32 @@
+import { DOCUMENT } from '@angular/common';
+import { Router } from '@angular/router';
+import { DA_SERVICE_TOKEN } from './interface';
+export function CheckSimple(model) {
+    return model != null && typeof model.token === 'string' && model.token.length > 0;
+}
+export function CheckJwt(model, offset) {
+    try {
+        return model != null && !!model.token && !model.isExpired(offset);
+    }
+    catch (err) {
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            console.warn(`${err.message}, jump to login_url`);
+        }
+        return false;
+    }
+}
+export function ToLogin(options, injector, url) {
+    const router = injector.get(Router);
+    injector.get(DA_SERVICE_TOKEN).referrer.url = url || router.url;
+    if (options.token_invalid_redirect === true) {
+        setTimeout(() => {
+            if (/^https?:\/\//g.test(options.login_url)) {
+                injector.get(DOCUMENT).location.href = options.login_url;
+            }
+            else {
+                router.navigate([options.login_url]);
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/token/jwt/jwt.guard.mjs

@@ -0,0 +1,63 @@
+import { Inject, Injectable } from '@angular/core';
+import { CheckJwt, ToLogin } from '../helper';
+import { DA_SERVICE_TOKEN } from '../interface';
+import { JWTTokenModel } from './jwt.model';
+import * as i0 from "@angular/core";
+/**
+ * JWT 路由守卫, [ACL Document](https://ng-alain.com/auth/guard).
+ *
+ * ```ts
+ * data: {
+ *  path: 'home',
+ *  canActivate: [ JWTGuard ]
+ * },
+ * {
+ *   path: 'my',
+ *   canActivateChild: [JWTGuard],
+ *   children: [
+ *     { path: 'profile', component: MockComponent }
+ *   ],
+ * },
+ * ```
+ */
+export class JWTGuard {
+    constructor(srv, injector) {
+        this.srv = srv;
+        this.injector = injector;
+    }
+    get cog() {
+        return this.srv.options;
+    }
+    process() {
+        const res = CheckJwt(this.srv.get(JWTTokenModel), this.cog.token_exp_offset);
+        if (!res) {
+            ToLogin(this.cog, this.injector, this.url);
+        }
+        return res;
+    }
+    // lazy loading
+    canLoad(route, _segments) {
+        this.url = route.path;
+        return this.process();
+    }
+    // all children route
+    canActivateChild(_childRoute, state) {
+        this.url = state.url;
+        return this.process();
+    }
+    // route
+    canActivate(_route, state) {
+        this.url = state.url;
+        return this.process();
+    }
+}
+JWTGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: JWTGuard, deps: [{ token: DA_SERVICE_TOKEN }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+JWTGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: JWTGuard, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: JWTGuard, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DA_SERVICE_TOKEN]
+                }] }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/token/jwt/jwt.interceptor.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { BaseInterceptor } from '../base.interceptor';
+import { CheckJwt } from '../helper';
+import { DA_SERVICE_TOKEN } from '../interface';
+import { JWTTokenModel } from './jwt.model';
+import * as i0 from "@angular/core";
+/**
+ * JWT 拦截器
+ *
+ * ```
+ * // app.module.ts
+ * { provide: HTTP_INTERCEPTORS, useClass: JWTInterceptor, multi: true}
+ * ```
+ */
+export class JWTInterceptor extends BaseInterceptor {
+    isAuth(options) {
+        this.model = this.injector.get(DA_SERVICE_TOKEN).get(JWTTokenModel);
+        return CheckJwt(this.model, options.token_exp_offset);
+    }
+    setReq(req, _options) {
+        return req.clone({
+            setHeaders: {
+                Authorization: `Bearer ${this.model.token}`
+            }
+        });
+    }
+}
+JWTInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: JWTInterceptor, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+JWTInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: JWTInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: JWTInterceptor, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiand0LmludGVyY2VwdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYXV0aC9zcmMvdG9rZW4vand0L2p3dC5pbnRlcmNlcHRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBSzNDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN0RCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQ3JDLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUNoRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sYUFBYSxDQUFDOztBQUU1Qzs7Ozs7OztHQU9HO0FBRUgsTUFBTSxPQUFPLGNBQWUsU0FBUSxlQUFlO0lBQ2pELE1BQU0sQ0FBQyxPQUF3QjtRQUM3QixJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLGdCQUFnQixDQUFDLENBQUMsR0FBRyxDQUFnQixhQUFhLENBQUMsQ0FBQztRQUNuRixPQUFPLFFBQVEsQ0FBQyxJQUFJLENBQUMsS0FBc0IsRUFBRSxPQUFPLENBQUMsZ0JBQWlCLENBQUMsQ0FBQztJQUMxRSxDQUFDO0lBRUQsTUFBTSxDQUFDLEdBQTJCLEVBQUUsUUFBeUI7UUFDM0QsT0FBTyxHQUFHLENBQUMsS0FBSyxDQUFDO1lBQ2YsVUFBVSxFQUFFO2dCQUNWLGFBQWEsRUFBRSxVQUFVLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxFQUFFO2FBQzVDO1NBQ0YsQ0FBQyxDQUFDO0lBQ0wsQ0FBQzs7MkdBWlUsY0FBYzsrR0FBZCxjQUFjOzJGQUFkLGNBQWM7a0JBRDFCLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBIdHRwUmVxdWVzdCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgQWxhaW5BdXRoQ29uZmlnIH0gZnJvbSAnQGRlbG9uL3V0aWwvY29uZmlnJztcbmltcG9ydCB0eXBlIHsgTnpTYWZlQW55IH0gZnJvbSAnbmctem9ycm8tYW50ZC9jb3JlL3R5cGVzJztcblxuaW1wb3J0IHsgQmFzZUludGVyY2VwdG9yIH0gZnJvbSAnLi4vYmFzZS5pbnRlcmNlcHRvcic7XG5pbXBvcnQgeyBDaGVja0p3dCB9IGZyb20gJy4uL2hlbHBlcic7XG5pbXBvcnQgeyBEQV9TRVJWSUNFX1RPS0VOIH0gZnJvbSAnLi4vaW50ZXJmYWNlJztcbmltcG9ydCB7IEpXVFRva2VuTW9kZWwgfSBmcm9tICcuL2p3dC5tb2RlbCc7XG5cbi8qKlxuICogSldUIOaLpuaIquWZqFxuICpcbiAqIGBgYFxuICogLy8gYXBwLm1vZHVsZS50c1xuICogeyBwcm92aWRlOiBIVFRQX0lOVEVSQ0VQVE9SUywgdXNlQ2xhc3M6IEpXVEludGVyY2VwdG9yLCBtdWx0aTogdHJ1ZX1cbiAqIGBgYFxuICovXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgSldUSW50ZXJjZXB0b3IgZXh0ZW5kcyBCYXNlSW50ZXJjZXB0b3Ige1xuICBpc0F1dGgob3B0aW9uczogQWxhaW5BdXRoQ29uZmlnKTogYm9vbGVhbiB7XG4gICAgdGhpcy5tb2RlbCA9IHRoaXMuaW5qZWN0b3IuZ2V0KERBX1NFUlZJQ0VfVE9LRU4pLmdldDxKV1RUb2tlbk1vZGVsPihKV1RUb2tlbk1vZGVsKTtcbiAgICByZXR1cm4gQ2hlY2tKd3QodGhpcy5tb2RlbCBhcyBKV1RUb2tlbk1vZGVsLCBvcHRpb25zLnRva2VuX2V4cF9vZmZzZXQhKTtcbiAgfVxuXG4gIHNldFJlcShyZXE6IEh0dHBSZXF1ZXN0PE56U2FmZUFueT4sIF9vcHRpb25zOiBBbGFpbkF1dGhDb25maWcpOiBIdHRwUmVxdWVzdDxOelNhZmVBbnk+IHtcbiAgICByZXR1cm4gcmVxLmNsb25lKHtcbiAgICAgIHNldEhlYWRlcnM6IHtcbiAgICAgICAgQXV0aG9yaXphdGlvbjogYEJlYXJlciAke3RoaXMubW9kZWwudG9rZW59YFxuICAgICAgfVxuICAgIH0pO1xuICB9XG59XG4iXX0=

package/esm2020/src/token/simple/simple.guard.mjs

@@ -0,0 +1,62 @@
+import { Inject, Injectable } from '@angular/core';
+import { CheckSimple, ToLogin } from '../helper';
+import { DA_SERVICE_TOKEN } from '../interface';
+import * as i0 from "@angular/core";
+/**
+ * Simple 路由守卫, [ACL Document](https://ng-alain.com/auth/guard).
+ *
+ * ```ts
+ * data: {
+ *  path: 'home',
+ *  canActivate: [ SimpleGuard ]
+ * },
+ * {
+ *   path: 'my',
+ *   canActivateChild: [SimpleGuard],
+ *   children: [
+ *     { path: 'profile', component: MockComponent }
+ *   ],
+ * },
+ * ```
+ */
+export class SimpleGuard {
+    constructor(srv, injector) {
+        this.srv = srv;
+        this.injector = injector;
+    }
+    get cog() {
+        return this.srv.options;
+    }
+    process() {
+        const res = CheckSimple(this.srv.get());
+        if (!res) {
+            ToLogin(this.cog, this.injector, this.url);
+        }
+        return res;
+    }
+    // lazy loading
+    canLoad(route, _segments) {
+        this.url = route.path;
+        return this.process();
+    }
+    // all children route
+    canActivateChild(_childRoute, state) {
+        this.url = state.url;
+        return this.process();
+    }
+    // route
+    canActivate(_route, state) {
+        this.url = state.url;
+        return this.process();
+    }
+}
+SimpleGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: SimpleGuard, deps: [{ token: DA_SERVICE_TOKEN }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+SimpleGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: SimpleGuard, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: SimpleGuard, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DA_SERVICE_TOKEN]
+                }] }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/token/simple/simple.interceptor.mjs

@@ -0,0 +1,51 @@
+import { Injectable } from '@angular/core';
+import { BaseInterceptor } from '../base.interceptor';
+import { CheckSimple } from '../helper';
+import { DA_SERVICE_TOKEN } from '../interface';
+import * as i0 from "@angular/core";
+/**
+ * Simple 拦截器
+ *
+ * ```
+ * // app.module.ts
+ * { provide: HTTP_INTERCEPTORS, useClass: SimpleInterceptor, multi: true}
+ * ```
+ */
+export class SimpleInterceptor extends BaseInterceptor {
+    isAuth(_options) {
+        this.model = this.injector.get(DA_SERVICE_TOKEN).get();
+        return CheckSimple(this.model);
+    }
+    setReq(req, options) {
+        const { token_send_template, token_send_key } = options;
+        const token = token_send_template.replace(/\$\{([\w]+)\}/g, (_, g) => this.model[g]);
+        switch (options.token_send_place) {
+            case 'header':
+                const obj = {};
+                obj[token_send_key] = token;
+                req = req.clone({
+                    setHeaders: obj
+                });
+                break;
+            case 'body':
+                const body = req.body || {};
+                body[token_send_key] = token;
+                req = req.clone({
+                    body
+                });
+                break;
+            case 'url':
+                req = req.clone({
+                    params: req.params.append(token_send_key, token)
+                });
+                break;
+        }
+        return req;
+    }
+}
+SimpleInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: SimpleInterceptor, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+SimpleInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: SimpleInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: SimpleInterceptor, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/src/token/simple/simple.model.js → esm2020/src/token/simple/simple.model.mjs}

@@ -1,3 +1,3 @@
 export class SimpleTokenModel {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2ltcGxlLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYXV0aC9zcmMvdG9rZW4vc2ltcGxlL3NpbXBsZS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLE9BQU8sZ0JBQWdCO0NBTTVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBOelNhZmVBbnkgfSBmcm9tICduZy16b3Jyby1hbnRkL2NvcmUvdHlwZXMnO1xuXG5pbXBvcnQgeyBJVG9rZW5Nb2RlbCB9IGZyb20gJy4uL2ludGVyZmFjZSc7XG5cbmV4cG9ydCBjbGFzcyBTaW1wbGVUb2tlbk1vZGVsIGltcGxlbWVudHMgSVRva2VuTW9kZWwge1xuICBba2V5OiBzdHJpbmddOiBOelNhZmVBbnk7XG5cbiAgdG9rZW46IHN0cmluZztcblxuICBleHBpcmVkPzogbnVtYmVyO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2ltcGxlLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYXV0aC9zcmMvdG9rZW4vc2ltcGxlL3NpbXBsZS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLE9BQU8sZ0JBQWdCO0NBTTVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBOelNhZmVBbnkgfSBmcm9tICduZy16b3Jyby1hbnRkL2NvcmUvdHlwZXMnO1xuXG5pbXBvcnQgeyBJVG9rZW5Nb2RlbCB9IGZyb20gJy4uL2ludGVyZmFjZSc7XG5cbmV4cG9ydCBjbGFzcyBTaW1wbGVUb2tlbk1vZGVsIGltcGxlbWVudHMgSVRva2VuTW9kZWwge1xuICBba2V5OiBzdHJpbmddOiBOelNhZmVBbnk7XG5cbiAgdG9rZW46IHN0cmluZyB8IG51bGwgfCB1bmRlZmluZWQ7XG5cbiAgZXhwaXJlZD86IG51bWJlcjtcbn1cbiJdfQ==