@delon/auth 15.2.1 → 16.0.0

package/esm2022/src/auth.module.mjs

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

package/esm2022/src/social/social.service.mjs

@@ -0,0 +1,107 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+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';
+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;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: SocialService, deps: [{ token: DA_SERVICE_TOKEN }, { token: DOCUMENT }, { token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: SocialService }); }
+}
+export { SocialService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.4", 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":"AAAA,uDAAuD;AACvD,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAa,MAAM,eAAe,CAAC;AAE9D,OAAO,EAAE,UAAU,EAAY,MAAM,MAAM,CAAC;AAE5C,OAAO,EAAE,gBAAgB,EAA8B,MAAM,oBAAoB,CAAC;;;AAElF,MAAM,QAAQ,GAAG,sBAAsB,CAAC;AACxC,MAAM,YAAY,GAAG,gCAAgC,CAAC;AAItD,MACa,aAAa;IAKxB,YACoC,YAA2B,EACnC,GAAQ,EAC1B,MAAc;QAFY,iBAAY,GAAZ,YAAY,CAAe;QACnC,QAAG,GAAH,GAAG,CAAK;QAC1B,WAAM,GAAN,MAAM,CAAQ;QAPhB,SAAI,GAAkB,IAAI,CAAC;IAQhC,CAAC;IAgCJ;;;;;;;OAOG;IACH,KAAK,CACH,GAAW,EACX,WAAmB,GAAG,EACtB,UAGI,EAAE;QAEN,OAAO,GAAG;YACR,IAAI,EAAE,QAAQ;YACd,cAAc,EAAE,6DAA6D;YAC7E,GAAG,OAAO;SACX,CAAC;QACF,YAAY,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAK,CAAC,CAAC;QAC9C,YAAY,CAAC,OAAO,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;QAC7C,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,EAAE;YAC3B,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,GAAG,GAAG,CAAC;YAC7B,OAAO;SACR;QAED,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;QAC/D,IAAI,CAAC,QAAQ,GAAG,WAAW,CAAC,GAAG,EAAE;YAC/B,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;gBACjC,IAAI,CAAC,WAAW,EAAE,CAAC;gBAEnB,IAAI,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC;gBACpC,IAAI,KAAK,IAAI,CAAC,KAAK,CAAC,KAAK;oBAAE,KAAK,GAAG,IAAI,CAAC;gBAExC,SAAS;gBACT,IAAI,KAAK,EAAE;oBACT,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;iBAC9B;gBAED,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC1B,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;aAC1B;QACH,CAAC,EAAE,GAAG,CAAC,CAAC;QACR,OAAO,IAAI,UAAU,CAAC,CAAC,QAAsC,EAAE,EAAE;YAC/D,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAC3B,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,QAAQ,CAAC,OAAqC;QAC5C,WAAW;QACX,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE;YACnD,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;SACzC;QACD,QAAQ;QACR,IAAI,IAAI,GAAgB,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;QACtC,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;YAC/B,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YACrD,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,QAAQ,EAAE,CAAC,CAAC,WAA0B,CAAC;SAC1E;aAAM;YACL,IAAI,GAAG,OAAsB,CAAC;SAC/B;QAED,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK;YAAE,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACjE,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAE5B,MAAM,GAAG,GAAG,YAAY,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,GAAG,CAAC;QACtD,YAAY,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;QACtC,MAAM,IAAI,GAAG,YAAY,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC5C,YAAY,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QAClC,IAAI,IAAI,KAAK,QAAQ,EAAE;YACrB,MAAM,CAAC,KAAK,EAAE,CAAC;SAChB;aAAM;YACL,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;SAChC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED,WAAW;QACT,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC7B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;IACvB,CAAC;8GAjIU,aAAa,kBAMd,gBAAgB,aAChB,QAAQ;kHAPP,aAAa;;SAAb,aAAa;2FAAb,aAAa;kBADzB,UAAU;;0BAON,MAAM;2BAAC,gBAAgB;;0BACvB,MAAM;2BAAC,QAAQ","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { DOCUMENT } from '@angular/common';\nimport { Inject, Injectable, OnDestroy } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { Observable, Observer } from 'rxjs';\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: any;\n  private observer!: Observer<ITokenModel | null>;\n\n  constructor(\n    @Inject(DA_SERVICE_TOKEN) private tokenService: ITokenService,\n    @Inject(DOCUMENT) private doc: any,\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/esm2022/src/token/base.interceptor.mjs

@@ -0,0 +1,75 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpErrorResponse, 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 { ALLOW_ANONYMOUS } from '../token';
+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);
+    }
+}
+class BaseInterceptor {
+    constructor(injector) {
+        this.injector = injector;
+    }
+    intercept(req, next) {
+        if (req.context.get(ALLOW_ANONYMOUS))
+            return next.handle(req);
+        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);
+            }
+        }
+        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) => {
+                let statusText = '';
+                if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                    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`;
+                }
+                const res = new HttpErrorResponse({
+                    url: req.url,
+                    headers: req.headers,
+                    status: 401,
+                    statusText
+                });
+                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);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: BaseInterceptor, deps: [{ token: i0.Injector, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: BaseInterceptor }); }
+}
+export { BaseInterceptor };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: BaseInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,64 @@
+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 }
+ *   ],
+ * },
+ * ```
+ */
+class JWTGuard {
+    get cog() {
+        return this.srv.options;
+    }
+    constructor(srv, injector) {
+        this.srv = srv;
+        this.injector = injector;
+    }
+    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
+    canMatch(route) {
+        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();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: JWTGuard, deps: [{ token: DA_SERVICE_TOKEN }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: JWTGuard, providedIn: 'root' }); }
+}
+export { JWTGuard };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.4", 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/esm2022/src/token/jwt/jwt.interceptor.mjs

@@ -0,0 +1,35 @@
+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}
+ * ```
+ */
+class JWTInterceptor extends BaseInterceptor {
+    isAuth(options) {
+        this.model = this.injector.get(DA_SERVICE_TOKEN).get(JWTTokenModel);
+        return CheckJwt(this.model, options.token_exp_offset);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    setReq(req, _options) {
+        return req.clone({
+            setHeaders: {
+                Authorization: `Bearer ${this.model.token}`
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: JWTInterceptor, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: JWTInterceptor }); }
+}
+export { JWTInterceptor };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: JWTInterceptor, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,63 @@
+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 }
+ *   ],
+ * },
+ * ```
+ */
+class SimpleGuard {
+    get cog() {
+        return this.srv.options;
+    }
+    constructor(srv, injector) {
+        this.srv = srv;
+        this.injector = injector;
+    }
+    process() {
+        const res = CheckSimple(this.srv.get());
+        if (!res) {
+            ToLogin(this.cog, this.injector, this.url);
+        }
+        return res;
+    }
+    // lazy loading
+    canMatch(route) {
+        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();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: SimpleGuard, deps: [{ token: DA_SERVICE_TOKEN }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: SimpleGuard, providedIn: 'root' }); }
+}
+export { SimpleGuard };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.4", 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/esm2022/src/token/simple/simple.interceptor.mjs

@@ -0,0 +1,52 @@
+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}
+ * ```
+ */
+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;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: SimpleInterceptor, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: SimpleInterceptor }); }
+}
+export { SimpleInterceptor };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: SimpleInterceptor, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/token/token.service.mjs

@@ -0,0 +1,92 @@
+import { inject, Inject, Injectable } from '@angular/core';
+import { BehaviorSubject, interval, Subject, filter, map, share } from 'rxjs';
+import { AlainConfigService } from '@delon/util/config';
+import { mergeConfig } from '../auth.config';
+import { DA_STORE_TOKEN } from '../store/interface';
+import * as i0 from "@angular/core";
+import * as i1 from "@delon/util/config";
+export function DA_SERVICE_TOKEN_FACTORY() {
+    return new TokenService(inject(AlainConfigService), inject(DA_STORE_TOKEN));
+}
+/**
+ * 维护Token信息服务，[在线文档](https://ng-alain.com/auth)
+ */
+class TokenService {
+    constructor(configSrv, store) {
+        this.store = store;
+        this.refresh$ = new Subject();
+        this.change$ = new BehaviorSubject(null);
+        this._referrer = {};
+        this._options = mergeConfig(configSrv);
+    }
+    get refresh() {
+        this.builderRefresh();
+        return this.refresh$.pipe(share());
+    }
+    get login_url() {
+        return this._options.login_url;
+    }
+    get referrer() {
+        return this._referrer;
+    }
+    get options() {
+        return this._options;
+    }
+    set(data) {
+        const res = this.store.set(this._options.store_key, data);
+        this.change$.next(data);
+        return res;
+    }
+    get(type) {
+        const data = this.store.get(this._options.store_key);
+        return type ? Object.assign(new type(), data) : data;
+    }
+    clear(options = { onlyToken: false }) {
+        let data = null;
+        if (options.onlyToken === true) {
+            data = this.get();
+            data.token = ``;
+            this.set(data);
+        }
+        else {
+            this.store.remove(this._options.store_key);
+        }
+        this.change$.next(data);
+    }
+    change() {
+        return this.change$.pipe(share());
+    }
+    builderRefresh() {
+        const { refreshTime, refreshOffset } = this._options;
+        this.cleanRefresh();
+        this.interval$ = interval(refreshTime)
+            .pipe(map(() => {
+            const item = this.get();
+            const expired = item.expired || item.exp || 0;
+            if (expired <= 0) {
+                return null;
+            }
+            const curTime = new Date().valueOf() + refreshOffset;
+            return expired <= curTime ? item : null;
+        }), filter(v => v != null))
+            .subscribe(res => this.refresh$.next(res));
+    }
+    cleanRefresh() {
+        if (this.interval$ && !this.interval$.closed) {
+            this.interval$.unsubscribe();
+        }
+    }
+    ngOnDestroy() {
+        this.cleanRefresh();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: TokenService, deps: [{ token: i1.AlainConfigService }, { token: DA_STORE_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: TokenService }); }
+}
+export { TokenService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: TokenService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.AlainConfigService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DA_STORE_TOKEN]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token.service.js","sourceRoot":"","sources":["../../../../../../packages/auth/src/token/token.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Inject, Injectable, OnDestroy } from '@angular/core';\nimport { BehaviorSubject, interval, Observable, Subject, Subscription, filter, map, share } from 'rxjs';\n\nimport { AlainAuthConfig, AlainConfigService } from '@delon/util/config';\n\nimport { mergeConfig } from '../auth.config';\nimport { DA_STORE_TOKEN, IStore } from '../store/interface';\nimport { AuthReferrer, ITokenModel, ITokenService } from './interface';\n\nexport function DA_SERVICE_TOKEN_FACTORY(): ITokenService {\n  return new TokenService(inject(AlainConfigService), inject(DA_STORE_TOKEN));\n}\n\n/**\n * 维护Token信息服务，[在线文档](https://ng-alain.com/auth)\n */\n@Injectable()\nexport class TokenService implements ITokenService, OnDestroy {\n  private refresh$ = new Subject<ITokenModel>();\n  private change$ = new BehaviorSubject<ITokenModel | null>(null);\n  private interval$?: Subscription;\n  private _referrer: AuthReferrer = {};\n  private _options: AlainAuthConfig;\n\n  constructor(configSrv: AlainConfigService, @Inject(DA_STORE_TOKEN) private store: IStore) {\n    this._options = mergeConfig(configSrv);\n  }\n\n  get refresh(): Observable<ITokenModel> {\n    this.builderRefresh();\n    return this.refresh$.pipe(share());\n  }\n\n  get login_url(): string | undefined {\n    return this._options.login_url;\n  }\n\n  get referrer(): AuthReferrer {\n    return this._referrer;\n  }\n\n  get options(): AlainAuthConfig {\n    return this._options;\n  }\n\n  set(data: ITokenModel): boolean {\n    const res = this.store.set(this._options.store_key!, data);\n    this.change$.next(data);\n    return res;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  get(type?: any): any;\n  get<T extends ITokenModel>(type?: new () => T): T;\n  get<T extends ITokenModel>(type?: new () => T): T {\n    const data = this.store.get(this._options.store_key!);\n    return type ? (Object.assign(new type(), data) as T) : (data as T);\n  }\n\n  clear(options: { onlyToken: boolean } = { onlyToken: false }): void {\n    let data: ITokenModel | null = null;\n    if (options.onlyToken === true) {\n      data = this.get() as ITokenModel;\n      data.token = ``;\n      this.set(data);\n    } else {\n      this.store.remove(this._options.store_key!);\n    }\n    this.change$.next(data);\n  }\n\n  change(): Observable<ITokenModel | null> {\n    return this.change$.pipe(share());\n  }\n\n  private builderRefresh(): void {\n    const { refreshTime, refreshOffset } = this._options;\n    this.cleanRefresh();\n    this.interval$ = interval(refreshTime)\n      .pipe(\n        map(() => {\n          const item = this.get() as ITokenModel;\n          const expired = item.expired || item.exp || 0;\n          if (expired <= 0) {\n            return null;\n          }\n\n          const curTime = new Date().valueOf() + refreshOffset!;\n          return expired <= curTime ? item : null;\n        }),\n        filter(v => v != null)\n      )\n      .subscribe(res => this.refresh$.next(res!));\n  }\n\n  private cleanRefresh(): void {\n    if (this.interval$ && !this.interval$.closed) {\n      this.interval$.unsubscribe();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.cleanRefresh();\n  }\n}\n"]}