@delon/auth 12.4.2 → 13.1.0

package/fesm2020/auth.mjs

@@ -0,0 +1,717 @@
+import { DOCUMENT } from '@angular/common';
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injectable, Inject, Optional, NgModule } from '@angular/core';
+import { Subject, BehaviorSubject, interval, Observable } from 'rxjs';
+import { share, map, filter } from 'rxjs/operators';
+import * as i1 from '@delon/util/config';
+import { AlainConfigService } from '@delon/util/config';
+import * as i1$1 from '@angular/router';
+import { Router } from '@angular/router';
+import { HttpParams, HttpErrorResponse, HTTP_INTERCEPTORS } from '@angular/common/http';
+
+const AUTH_DEFAULT_CONFIG = {
+    store_key: `_token`,
+    token_invalid_redirect: true,
+    token_exp_offset: 10,
+    token_send_key: `token`,
+    token_send_template: '${token}',
+    token_send_place: 'header',
+    login_url: '/login',
+    ignores: [/\/login/, /assets\//, /passport\//],
+    allow_anonymous_key: `_allow_anonymous`,
+    executeOtherInterceptors: true,
+    refreshTime: 3000,
+    refreshOffset: 6000
+};
+function mergeConfig(srv) {
+    return srv.merge('auth', AUTH_DEFAULT_CONFIG);
+}
+
+function DA_STORE_TOKEN_LOCAL_FACTORY() {
+    return new LocalStorageStore();
+}
+/**
+ * `localStorage` storage, **not lost after closing the browser**.
+ *
+ * ```ts
+ * // global-config.module.ts
+ * { provide: DA_STORE_TOKEN, useClass: LocalStorageStore }
+ * ```
+ */
+class LocalStorageStore {
+    get(key) {
+        return JSON.parse(localStorage.getItem(key) || '{}') || {};
+    }
+    set(key, value) {
+        localStorage.setItem(key, JSON.stringify(value));
+        return true;
+    }
+    remove(key) {
+        localStorage.removeItem(key);
+    }
+}
+
+const DA_STORE_TOKEN = new InjectionToken('AUTH_STORE_TOKEN', {
+    providedIn: 'root',
+    factory: DA_STORE_TOKEN_LOCAL_FACTORY
+});
+
+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();
+    }
+}
+TokenService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: TokenService, deps: [{ token: i1.AlainConfigService }, { token: DA_STORE_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+TokenService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: TokenService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: TokenService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.AlainConfigService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DA_STORE_TOKEN]
+                }] }]; } });
+
+const DA_SERVICE_TOKEN = new InjectionToken('DA_SERVICE_TOKEN', {
+    providedIn: 'root',
+    factory: DA_SERVICE_TOKEN_FACTORY
+});
+
+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;
+    }
+}
+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$1.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$1.Router }]; } });
+
+/**
+ * 内存存储，关掉浏览器标签后**丢失**。
+ *
+ * ```ts
+ * // global-config.module.ts
+ * { provide: DA_STORE_TOKEN, useClass: MemoryStore }
+ * ```
+ */
+class MemoryStore {
+    constructor() {
+        this.cache = {};
+    }
+    get(key) {
+        return this.cache[key] || {};
+    }
+    set(key, value) {
+        this.cache[key] = value;
+        return true;
+    }
+    remove(key) {
+        this.cache[key] = null;
+    }
+}
+
+/**
+ * `sessionStorage` storage, **lost after closing the browser**.
+ *
+ * ```ts
+ * // global-config.module.ts
+ * { provide: DA_STORE_TOKEN, useClass: SessionStorageStore }
+ * ```
+ */
+class SessionStorageStore {
+    get(key) {
+        return JSON.parse(sessionStorage.getItem(key) || '{}') || {};
+    }
+    set(key, value) {
+        sessionStorage.setItem(key, JSON.stringify(value));
+        return true;
+    }
+    remove(key) {
+        sessionStorage.removeItem(key);
+    }
+}
+
+/**
+ * `cookie` storage
+ *
+ * ```ts
+ * // global-config.module.ts
+ * { provide: DA_STORE_TOKEN, useClass: CookieStorageStore, deps: [CookieService] }
+ * ```
+ */
+class CookieStorageStore {
+    constructor(srv) {
+        this.srv = srv;
+    }
+    get(key) {
+        return JSON.parse(this.srv.get(key) || '{}') || {};
+    }
+    set(key, value) {
+        this.srv.put(key, value != null ? JSON.stringify(value) : '{}');
+        return true;
+    }
+    remove(key) {
+        this.srv.remove(key);
+    }
+}
+
+function CheckSimple(model) {
+    return model != null && typeof model.token === 'string' && model.token.length > 0;
+}
+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;
+    }
+}
+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]);
+            }
+        });
+    }
+}
+
+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) {
+        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
+                }] }]; } });
+
+function urlBase64Decode(str) {
+    let output = str.replace(/-/g, '+').replace(/_/g, '/');
+    switch (output.length % 4) {
+        case 0: {
+            break;
+        }
+        case 2: {
+            output += '==';
+            break;
+        }
+        case 3: {
+            output += '=';
+            break;
+        }
+        default: {
+            throw new Error(`'atob' failed: The string to be decoded is not correctly encoded.`);
+        }
+    }
+    return b64DecodeUnicode(output);
+}
+function b64decode(str) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+    let output = '';
+    str = String(str).replace(/=+$/, '');
+    for (
+    // initialize result and counters
+    let bc = 0, bs, buffer, idx = 0; 
+    // get next character
+    (buffer = str.charAt(idx++)); 
+    // character found in table? initialize bit storage and add its ascii value;
+    ~buffer &&
+        ((bs = bc % 4 ? bs * 64 + buffer : buffer),
+            // and if not first of each 4 characters,
+            // convert the first 8 bits to one ascii character
+            bc++ % 4)
+        ? (output += String.fromCharCode(255 & (bs >> ((-2 * bc) & 6))))
+        : 0) {
+        // try to find character in table (0-63, not found => -1)
+        buffer = chars.indexOf(buffer);
+    }
+    return output;
+}
+// https://developer.mozilla.org/en/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#The_Unicode_Problem
+function b64DecodeUnicode(str) {
+    return decodeURIComponent(Array.prototype.map
+        .call(b64decode(str), (c) => {
+        return `%${`00${c.charCodeAt(0).toString(16)}`.slice(-2)}`;
+    })
+        .join(''));
+}
+
+class JWTTokenModel {
+    /**
+     * 获取载荷信息
+     */
+    get payload() {
+        const parts = (this.token || '').split('.');
+        if (parts.length !== 3)
+            throw new Error('JWT must have 3 parts');
+        const decoded = urlBase64Decode(parts[1]);
+        return JSON.parse(decoded);
+    }
+    /**
+     * 获取过期时间戳（单位：ms）
+     */
+    get exp() {
+        const decoded = this.payload;
+        if (!decoded.hasOwnProperty('exp'))
+            return null;
+        const date = new Date(0);
+        date.setUTCSeconds(decoded.exp);
+        return date.valueOf();
+    }
+    /**
+     * 检查Token是否过期，当`payload` 包含 `exp` 字段时有效，若无 `exp` 字段直接返回 `null`
+     *
+     * @param offsetSeconds 偏移量
+     */
+    isExpired(offsetSeconds = 0) {
+        const exp = this.exp;
+        if (exp == null)
+            return null;
+        return !(exp > new Date().valueOf() + offsetSeconds * 1000);
+    }
+}
+
+/**
+ * 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);
+    }
+    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
+        }] });
+
+/**
+ * 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 {
+    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 }]; } });
+
+class SimpleTokenModel {
+}
+
+/**
+ * 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;
+    }
+}
+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
+        }] });
+
+/**
+ * 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 {
+    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 }]; } });
+
+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: [{}]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AUTH_DEFAULT_CONFIG, BaseInterceptor, CookieStorageStore, DA_SERVICE_TOKEN, DA_SERVICE_TOKEN_FACTORY, DA_STORE_TOKEN, DA_STORE_TOKEN_LOCAL_FACTORY, DelonAuthModule, JWTGuard, JWTInterceptor, JWTTokenModel, LocalStorageStore, MemoryStore, SessionStorageStore, SimpleGuard, SimpleInterceptor, SimpleTokenModel, SocialService, TokenService, mergeConfig, urlBase64Decode };
+//# sourceMappingURL=auth.mjs.map