@abp/ng.oauth 7.2.2 → 7.3.0-rc.1

package/{fesm2020 → fesm2022}/abp-ng.oauth.mjs

@@ -4,451 +4,475 @@ import { CommonModule } from '@angular/common';
 import * as i1 from 'angular-oauth2-oidc';
 import { OAuthService, OAuthErrorEvent, OAuthInfoEvent, OAuthModule, OAuthStorage } from 'angular-oauth2-oidc';
 import * as i2 from '@abp/ng.core';
-import { HttpErrorReporterService, EnvironmentService, ConfigStateService, SessionStateService, AbpLocalStorageService, TENANT_KEY, noop, CORE_OPTIONS, IS_EXTERNAL_REQUEST, NAVIGATE_TO_MANAGE_PROFILE, AuthService, AuthGuard, ApiInterceptor, PIPE_TO_LOGIN_FN_KEY, CHECK_AUTHENTICATION_STATE_FN_KEY } from '@abp/ng.core';
-import { of, from, pipe, lastValueFrom } from 'rxjs';
-import { filter, tap, switchMap, map, take, finalize } from 'rxjs/operators';
+import { HttpErrorReporterService, EnvironmentService, ConfigStateService, SessionStateService, AbpLocalStorageService, TENANT_KEY, noop, CORE_OPTIONS, IS_EXTERNAL_REQUEST, AuthService, NAVIGATE_TO_MANAGE_PROFILE, AuthGuard, ApiInterceptor, PIPE_TO_LOGIN_FN_KEY, CHECK_AUTHENTICATION_STATE_FN_KEY } from '@abp/ng.core';
+import { of, from, pipe, lastValueFrom, tap as tap$1, delay } from 'rxjs';
+import { filter, take, map, switchMap, tap, finalize } from 'rxjs/operators';
 import { Router } from '@angular/router';
 import { HttpHeaders, HTTP_INTERCEPTORS } from '@angular/common/http';
 import compare from 'just-compare';
 
 const oAuthStorage = localStorage;
 
-function clearOAuthStorage(storage = oAuthStorage) {
-    const keys = [
-        'access_token',
-        'id_token',
-        'refresh_token',
-        'nonce',
-        'PKCE_verifier',
-        'expires_at',
-        'id_token_claims_obj',
-        'id_token_expires_at',
-        'id_token_stored_at',
-        'access_token_stored_at',
-        'granted_scopes',
-        'session_state',
-    ];
-    keys.forEach(key => storage.removeItem(key));
+function clearOAuthStorage(storage = oAuthStorage) {
+    const keys = [
+        'access_token',
+        'id_token',
+        'refresh_token',
+        'nonce',
+        'PKCE_verifier',
+        'expires_at',
+        'id_token_claims_obj',
+        'id_token_expires_at',
+        'id_token_stored_at',
+        'access_token_stored_at',
+        'granted_scopes',
+        'session_state',
+    ];
+    keys.forEach(key => storage.removeItem(key));
 }
 
-class AuthFlowStrategy {
-    constructor(injector) {
-        this.injector = injector;
-        this.catchError = (err) => {
-            this.httpErrorReporter.reportError(err);
-            return of(null);
-        };
-        this.httpErrorReporter = injector.get(HttpErrorReporterService);
-        this.environment = injector.get(EnvironmentService);
-        this.configState = injector.get(ConfigStateService);
-        this.oAuthService = injector.get(OAuthService);
-        this.sessionState = injector.get(SessionStateService);
-        this.localStorageService = injector.get(AbpLocalStorageService);
-        this.oAuthConfig = this.environment.getEnvironment().oAuthConfig || {};
-        this.tenantKey = injector.get(TENANT_KEY);
-        this.listenToOauthErrors();
-    }
-    async init() {
-        if (this.oAuthConfig.clientId) {
-            const shouldClear = shouldStorageClear(this.oAuthConfig.clientId, oAuthStorage);
-            if (shouldClear)
-                clearOAuthStorage(oAuthStorage);
-        }
-        this.oAuthService.configure(this.oAuthConfig);
-        this.oAuthService.events
-            .pipe(filter(event => event.type === 'token_refresh_error'))
-            .subscribe(() => this.navigateToLogin());
-        return this.oAuthService
-            .loadDiscoveryDocument()
-            .then(() => {
-            if (this.oAuthService.hasValidAccessToken() || !this.oAuthService.getRefreshToken()) {
-                return Promise.resolve();
-            }
-            return this.refreshToken();
-        })
-            .catch(this.catchError);
-    }
-    refreshToken() {
-        return this.oAuthService.refreshToken().catch(() => clearOAuthStorage());
-    }
-    listenToOauthErrors() {
-        this.oAuthService.events
-            .pipe(filter(event => event instanceof OAuthErrorEvent), tap(() => clearOAuthStorage()), switchMap(() => this.configState.refreshAppState()))
-            .subscribe();
-    }
-}
-function shouldStorageClear(clientId, storage) {
-    const key = 'abpOAuthClientId';
-    if (!storage.getItem(key)) {
-        storage.setItem(key, clientId);
-        return false;
-    }
-    const shouldClear = storage.getItem(key) !== clientId;
-    if (shouldClear)
-        storage.setItem(key, clientId);
-    return shouldClear;
+class AuthFlowStrategy {
+    constructor(injector) {
+        this.injector = injector;
+        this.catchError = (err) => {
+            this.httpErrorReporter.reportError(err);
+            return of(null);
+        };
+        this.httpErrorReporter = injector.get(HttpErrorReporterService);
+        this.environment = injector.get(EnvironmentService);
+        this.configState = injector.get(ConfigStateService);
+        this.oAuthService = injector.get(OAuthService);
+        this.sessionState = injector.get(SessionStateService);
+        this.localStorageService = injector.get(AbpLocalStorageService);
+        this.oAuthConfig = this.environment.getEnvironment().oAuthConfig || {};
+        this.tenantKey = injector.get(TENANT_KEY);
+        this.router = injector.get(Router);
+        this.listenToOauthErrors();
+    }
+    async init() {
+        if (this.oAuthConfig.clientId) {
+            const shouldClear = shouldStorageClear(this.oAuthConfig.clientId, oAuthStorage);
+            if (shouldClear)
+                clearOAuthStorage(oAuthStorage);
+        }
+        this.oAuthService.configure(this.oAuthConfig);
+        this.oAuthService.events
+            .pipe(filter(event => event.type === 'token_refresh_error'))
+            .subscribe(() => this.navigateToLogin());
+        this.navigateToPreviousUrl();
+        return this.oAuthService
+            .loadDiscoveryDocument()
+            .then(() => {
+            if (this.oAuthService.hasValidAccessToken() || !this.oAuthService.getRefreshToken()) {
+                return Promise.resolve();
+            }
+            return this.refreshToken();
+        })
+            .catch(this.catchError);
+    }
+    navigateToPreviousUrl() {
+        const { responseType } = this.oAuthConfig;
+        if (responseType === 'code') {
+            this.oAuthService.events
+                .pipe(filter(event => event.type === 'token_received' && !!this.oAuthService.state), take(1), map(() => {
+                const redirect_uri = decodeURIComponent(this.oAuthService.state);
+                if (redirect_uri && redirect_uri !== '/') {
+                    return redirect_uri;
+                }
+                return '/';
+            }), switchMap(redirectUri => this.configState.getOne$('currentUser').pipe(filter(user => !!user?.isAuthenticated), tap(() => this.router.navigate([redirectUri])))))
+                .subscribe();
+        }
+    }
+    refreshToken() {
+        return this.oAuthService.refreshToken().catch(() => clearOAuthStorage());
+    }
+    listenToOauthErrors() {
+        this.oAuthService.events
+            .pipe(filter(event => event instanceof OAuthErrorEvent), tap(() => clearOAuthStorage()), switchMap(() => this.configState.refreshAppState()))
+            .subscribe();
+    }
+}
+function shouldStorageClear(clientId, storage) {
+    const key = 'abpOAuthClientId';
+    if (!storage.getItem(key)) {
+        storage.setItem(key, clientId);
+        return false;
+    }
+    const shouldClear = storage.getItem(key) !== clientId;
+    if (shouldClear)
+        storage.setItem(key, clientId);
+    return shouldClear;
 }
 
-class AuthCodeFlowStrategy extends AuthFlowStrategy {
-    constructor() {
-        super(...arguments);
-        this.isInternalAuth = false;
-    }
-    async init() {
-        return super
-            .init()
-            .then(() => this.oAuthService.tryLogin().catch(noop))
-            .then(() => this.oAuthService.setupAutomaticSilentRefresh({}, 'access_token'));
-    }
-    navigateToLogin(queryParams) {
-        this.oAuthService.initCodeFlow('', this.getCultureParams(queryParams));
-    }
-    checkIfInternalAuth(queryParams) {
-        this.oAuthService.initCodeFlow('', this.getCultureParams(queryParams));
-        return false;
-    }
-    logout(queryParams) {
-        return from(this.oAuthService.revokeTokenAndLogout(this.getCultureParams(queryParams)));
-    }
-    login(queryParams) {
-        this.oAuthService.initCodeFlow('', this.getCultureParams(queryParams));
-        return of(null);
-    }
-    getCultureParams(queryParams) {
-        const lang = this.sessionState.getLanguage();
-        const culture = { culture: lang, 'ui-culture': lang };
-        return { ...(lang && culture), ...queryParams };
-    }
+class AuthCodeFlowStrategy extends AuthFlowStrategy {
+    constructor() {
+        super(...arguments);
+        this.isInternalAuth = false;
+    }
+    async init() {
+        return super
+            .init()
+            .then(() => this.oAuthService.tryLogin().catch(noop))
+            .then(() => this.oAuthService.setupAutomaticSilentRefresh({}, 'access_token'));
+    }
+    navigateToLogin(queryParams) {
+        let additionalState = '';
+        if (queryParams?.returnUrl) {
+            additionalState = queryParams.returnUrl;
+        }
+        const cultureParams = this.getCultureParams(queryParams);
+        this.oAuthService.initCodeFlow(additionalState, cultureParams);
+    }
+    checkIfInternalAuth(queryParams) {
+        this.oAuthService.initCodeFlow('', this.getCultureParams(queryParams));
+        return false;
+    }
+    logout(queryParams) {
+        return from(this.oAuthService.revokeTokenAndLogout(this.getCultureParams(queryParams)));
+    }
+    login(queryParams) {
+        this.oAuthService.initCodeFlow('', this.getCultureParams(queryParams));
+        return of(null);
+    }
+    getCultureParams(queryParams) {
+        const lang = this.sessionState.getLanguage();
+        const culture = { culture: lang, 'ui-culture': lang };
+        return { ...(lang && culture), ...queryParams };
+    }
 }
 
-const cookieKey = 'rememberMe';
-const storageKey = 'passwordFlow';
-const pipeToLogin = function (params, injector) {
-    const configState = injector.get(ConfigStateService);
-    const router = injector.get(Router);
-    const localStorage = injector.get(AbpLocalStorageService);
-    return pipe(switchMap(() => configState.refreshAppState()), tap(() => {
-        setRememberMe(params.rememberMe, localStorage);
-        if (params.redirectUrl)
-            router.navigate([params.redirectUrl]);
-    }));
-};
-function setRememberMe(remember, localStorageService) {
-    removeRememberMe(localStorageService);
-    localStorageService.setItem(storageKey, 'true');
-    document.cookie = `${cookieKey}=true; path=/${remember ? ' ;expires=Fri, 31 Dec 9999 23:59:59 GMT' : ''}`;
-}
-function removeRememberMe(localStorageService) {
-    localStorageService.removeItem(storageKey);
-    document.cookie = cookieKey + '= ; path=/; expires = Thu, 01 Jan 1970 00:00:00 GMT';
+const cookieKey = 'rememberMe';
+const storageKey = 'passwordFlow';
+const pipeToLogin = function (params, injector) {
+    const configState = injector.get(ConfigStateService);
+    const router = injector.get(Router);
+    const localStorage = injector.get(AbpLocalStorageService);
+    return pipe(switchMap(() => configState.refreshAppState()), tap(() => {
+        setRememberMe(params.rememberMe, localStorage);
+        if (params.redirectUrl)
+            router.navigate([params.redirectUrl]);
+    }));
+};
+function setRememberMe(remember, localStorageService) {
+    removeRememberMe(localStorageService);
+    localStorageService.setItem(storageKey, 'true');
+    document.cookie = `${cookieKey}=true; path=/${remember ? ' ;expires=Fri, 31 Dec 9999 23:59:59 GMT' : ''}`;
+}
+function removeRememberMe(localStorageService) {
+    localStorageService.removeItem(storageKey);
+    document.cookie = cookieKey + '= ; path=/; expires = Thu, 01 Jan 1970 00:00:00 GMT';
 }
 
-function getCookieValueByName(name) {
-    const match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
-    return match ? match[2] : '';
-}
-class AuthPasswordFlowStrategy extends AuthFlowStrategy {
-    constructor() {
-        super(...arguments);
-        this.isInternalAuth = true;
-        this.cookieKey = 'rememberMe';
-        this.storageKey = 'passwordFlow';
-    }
-    listenToTokenExpiration() {
-        this.oAuthService.events
-            .pipe(filter(event => event instanceof OAuthInfoEvent &&
-            event.type === 'token_expires' &&
-            event.info === 'access_token'))
-            .subscribe(() => {
-            if (this.oAuthService.getRefreshToken()) {
-                this.refreshToken();
-            }
-            else {
-                this.oAuthService.logOut();
-                removeRememberMe(this.localStorageService);
-                this.configState.refreshAppState().subscribe();
-            }
-        });
-    }
-    async init() {
-        if (!getCookieValueByName(this.cookieKey) && localStorage.getItem(this.storageKey)) {
-            this.oAuthService.logOut();
-        }
-        return super.init().then(() => this.listenToTokenExpiration());
-    }
-    navigateToLogin(queryParams) {
-        const router = this.injector.get(Router);
-        return router.navigate(['/account/login'], { queryParams });
-    }
-    checkIfInternalAuth() {
-        return true;
-    }
-    login(params) {
-        const tenant = this.sessionState.getTenant();
-        return from(this.oAuthService.fetchTokenUsingPasswordFlow(params.username, params.password, new HttpHeaders({ ...(tenant && tenant.id && { [this.tenantKey]: tenant.id }) }))).pipe(pipeToLogin(params, this.injector));
-    }
-    logout(queryParams) {
-        const router = this.injector.get(Router);
-        return from(this.oAuthService.revokeTokenAndLogout(queryParams)).pipe(switchMap(() => this.configState.refreshAppState()), tap(() => {
-            router.navigateByUrl('/');
-            removeRememberMe(this.localStorageService);
-        }));
-    }
-    refreshToken() {
-        return this.oAuthService.refreshToken().catch(() => {
-            clearOAuthStorage();
-            removeRememberMe(this.localStorageService);
-        });
-    }
+function getCookieValueByName(name) {
+    const match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
+    return match ? match[2] : '';
+}
+class AuthPasswordFlowStrategy extends AuthFlowStrategy {
+    constructor() {
+        super(...arguments);
+        this.isInternalAuth = true;
+        this.cookieKey = 'rememberMe';
+        this.storageKey = 'passwordFlow';
+    }
+    listenToTokenExpiration() {
+        this.oAuthService.events
+            .pipe(filter(event => event instanceof OAuthInfoEvent &&
+            event.type === 'token_expires' &&
+            event.info === 'access_token'))
+            .subscribe(() => {
+            if (this.oAuthService.getRefreshToken()) {
+                this.refreshToken();
+            }
+            else {
+                this.oAuthService.logOut();
+                removeRememberMe(this.localStorageService);
+                this.configState.refreshAppState().subscribe();
+            }
+        });
+    }
+    async init() {
+        if (!getCookieValueByName(this.cookieKey) && localStorage.getItem(this.storageKey)) {
+            this.oAuthService.logOut();
+        }
+        return super.init().then(() => this.listenToTokenExpiration());
+    }
+    navigateToLogin(queryParams) {
+        const router = this.injector.get(Router);
+        return router.navigate(['/account/login'], { queryParams });
+    }
+    checkIfInternalAuth() {
+        return true;
+    }
+    login(params) {
+        const tenant = this.sessionState.getTenant();
+        return from(this.oAuthService.fetchTokenUsingPasswordFlow(params.username, params.password, new HttpHeaders({ ...(tenant && tenant.id && { [this.tenantKey]: tenant.id }) }))).pipe(pipeToLogin(params, this.injector));
+    }
+    logout(queryParams) {
+        const router = this.injector.get(Router);
+        return from(this.oAuthService.revokeTokenAndLogout(queryParams)).pipe(switchMap(() => this.configState.refreshAppState()), tap(() => {
+            router.navigateByUrl('/');
+            removeRememberMe(this.localStorageService);
+        }));
+    }
+    refreshToken() {
+        return this.oAuthService.refreshToken().catch(() => {
+            clearOAuthStorage();
+            removeRememberMe(this.localStorageService);
+        });
+    }
 }
 
-const AUTH_FLOW_STRATEGY = {
-    Code(injector) {
-        return new AuthCodeFlowStrategy(injector);
-    },
-    Password(injector) {
-        return new AuthPasswordFlowStrategy(injector);
-    },
+const AUTH_FLOW_STRATEGY = {
+    Code(injector) {
+        return new AuthCodeFlowStrategy(injector);
+    },
+    Password(injector) {
+        return new AuthPasswordFlowStrategy(injector);
+    },
 };
 
-class AbpOAuthService {
-    constructor(injector) {
-        this.injector = injector;
-        this.oAuthService = this.injector.get(OAuthService);
-    }
-    get isInternalAuth() {
-        return this.strategy.isInternalAuth;
-    }
-    async init() {
-        const environmentService = this.injector.get(EnvironmentService);
-        const result$ = environmentService.getEnvironment$().pipe(map(env => env?.oAuthConfig), filter(Boolean), tap(oAuthConfig => {
-            this.strategy =
-                oAuthConfig.responseType === 'code'
-                    ? AUTH_FLOW_STRATEGY.Code(this.injector)
-                    : AUTH_FLOW_STRATEGY.Password(this.injector);
-        }), switchMap(() => from(this.strategy.init())), take(1));
-        return await lastValueFrom(result$);
-    }
-    logout(queryParams) {
-        return this.strategy.logout(queryParams);
-    }
-    navigateToLogin(queryParams) {
-        this.strategy.navigateToLogin(queryParams);
-    }
-    login(params) {
-        return this.strategy.login(params);
-    }
-    get isAuthenticated() {
-        return this.oAuthService.hasValidAccessToken();
-    }
-    loginUsingGrant(grantType, parameters, headers) {
-        const { clientId: client_id, dummyClientSecret: client_secret } = this.oAuthService;
-        const access_token = this.oAuthService.getAccessToken();
-        const p = {
-            access_token,
-            grant_type: grantType,
-            client_id,
-            ...parameters,
-        };
-        if (client_secret) {
-            p['client_secret'] = client_secret;
-        }
-        return this.oAuthService.fetchTokenUsingGrant(grantType, p, headers);
-    }
-}
-AbpOAuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
-AbpOAuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
+class AbpOAuthService {
+    get isInternalAuth() {
+        return this.strategy.isInternalAuth;
+    }
+    constructor(injector) {
+        this.injector = injector;
+        this.oAuthService = this.injector.get(OAuthService);
+    }
+    async init() {
+        const environmentService = this.injector.get(EnvironmentService);
+        const result$ = environmentService.getEnvironment$().pipe(map(env => env?.oAuthConfig), filter(Boolean), tap(oAuthConfig => {
+            this.strategy =
+                oAuthConfig.responseType === 'code'
+                    ? AUTH_FLOW_STRATEGY.Code(this.injector)
+                    : AUTH_FLOW_STRATEGY.Password(this.injector);
+        }), switchMap(() => from(this.strategy.init())), take(1));
+        return await lastValueFrom(result$);
+    }
+    logout(queryParams) {
+        return this.strategy.logout(queryParams);
+    }
+    navigateToLogin(queryParams) {
+        this.strategy.navigateToLogin(queryParams);
+    }
+    login(params) {
+        return this.strategy.login(params);
+    }
+    get isAuthenticated() {
+        return this.oAuthService.hasValidAccessToken();
+    }
+    loginUsingGrant(grantType, parameters, headers) {
+        const { clientId: client_id, dummyClientSecret: client_secret } = this.oAuthService;
+        const access_token = this.oAuthService.getAccessToken();
+        const p = {
+            access_token,
+            grant_type: grantType,
+            client_id,
+            ...parameters,
+        };
+        if (client_secret) {
+            p['client_secret'] = client_secret;
+        }
+        return this.oAuthService.fetchTokenUsingGrant(grantType, p, headers);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
         }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 
-class OAuthConfigurationHandler {
-    constructor(oAuthService, environmentService, options) {
-        this.oAuthService = oAuthService;
-        this.environmentService = environmentService;
-        this.options = options;
-        this.listenToSetEnvironment();
-    }
-    listenToSetEnvironment() {
-        this.environmentService
-            .createOnUpdateStream(state => state)
-            .pipe(map(environment => environment.oAuthConfig), filter(config => !compare(config, this.options.environment.oAuthConfig)))
-            .subscribe((config) => {
-            this.oAuthService.configure(config);
-        });
-    }
-}
-OAuthConfigurationHandler.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: OAuthConfigurationHandler, deps: [{ token: i1.OAuthService }, { token: i2.EnvironmentService }, { token: CORE_OPTIONS }], target: i0.ɵɵFactoryTarget.Injectable });
-OAuthConfigurationHandler.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: OAuthConfigurationHandler, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: OAuthConfigurationHandler, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return [{ type: i1.OAuthService }, { type: i2.EnvironmentService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [CORE_OPTIONS]
+class OAuthConfigurationHandler {
+    constructor(oAuthService, environmentService, options) {
+        this.oAuthService = oAuthService;
+        this.environmentService = environmentService;
+        this.options = options;
+        this.listenToSetEnvironment();
+    }
+    listenToSetEnvironment() {
+        this.environmentService
+            .createOnUpdateStream(state => state)
+            .pipe(map(environment => environment.oAuthConfig), filter(config => !compare(config, this.options.environment.oAuthConfig)))
+            .subscribe((config) => {
+            this.oAuthService.configure(config);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: OAuthConfigurationHandler, deps: [{ token: i1.OAuthService }, { token: i2.EnvironmentService }, { token: CORE_OPTIONS }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: OAuthConfigurationHandler, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: OAuthConfigurationHandler, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.OAuthService }, { type: i2.EnvironmentService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CORE_OPTIONS]
                 }] }]; } });
 
-class OAuthApiInterceptor {
-    constructor(oAuthService, sessionState, httpWaitService, tenantKey) {
-        this.oAuthService = oAuthService;
-        this.sessionState = sessionState;
-        this.httpWaitService = httpWaitService;
-        this.tenantKey = tenantKey;
-    }
-    intercept(request, next) {
-        this.httpWaitService.addRequest(request);
-        const isExternalRequest = request.context?.get(IS_EXTERNAL_REQUEST);
-        const newRequest = isExternalRequest
-            ? request
-            : request.clone({
-                setHeaders: this.getAdditionalHeaders(request.headers),
-            });
-        return next
-            .handle(newRequest)
-            .pipe(finalize(() => this.httpWaitService.deleteRequest(request)));
-    }
-    getAdditionalHeaders(existingHeaders) {
-        const headers = {};
-        const token = this.oAuthService.getAccessToken();
-        if (!existingHeaders?.has('Authorization') && token) {
-            headers['Authorization'] = `Bearer ${token}`;
-        }
-        const lang = this.sessionState.getLanguage();
-        if (!existingHeaders?.has('Accept-Language') && lang) {
-            headers['Accept-Language'] = lang;
-        }
-        const tenant = this.sessionState.getTenant();
-        if (!existingHeaders?.has(this.tenantKey) && tenant?.id) {
-            headers[this.tenantKey] = tenant.id;
-        }
-        headers['X-Requested-With'] = 'XMLHttpRequest';
-        return headers;
-    }
-}
-OAuthApiInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: OAuthApiInterceptor, deps: [{ token: i1.OAuthService }, { token: i2.SessionStateService }, { token: i2.HttpWaitService }, { token: TENANT_KEY }], target: i0.ɵɵFactoryTarget.Injectable });
-OAuthApiInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: OAuthApiInterceptor, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: OAuthApiInterceptor, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return [{ type: i1.OAuthService }, { type: i2.SessionStateService }, { type: i2.HttpWaitService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [TENANT_KEY]
+class OAuthApiInterceptor {
+    constructor(oAuthService, sessionState, httpWaitService, tenantKey) {
+        this.oAuthService = oAuthService;
+        this.sessionState = sessionState;
+        this.httpWaitService = httpWaitService;
+        this.tenantKey = tenantKey;
+    }
+    intercept(request, next) {
+        this.httpWaitService.addRequest(request);
+        const isExternalRequest = request.context?.get(IS_EXTERNAL_REQUEST);
+        const newRequest = isExternalRequest
+            ? request
+            : request.clone({
+                setHeaders: this.getAdditionalHeaders(request.headers),
+            });
+        return next
+            .handle(newRequest)
+            .pipe(finalize(() => this.httpWaitService.deleteRequest(request)));
+    }
+    getAdditionalHeaders(existingHeaders) {
+        const headers = {};
+        const token = this.oAuthService.getAccessToken();
+        if (!existingHeaders?.has('Authorization') && token) {
+            headers['Authorization'] = `Bearer ${token}`;
+        }
+        const lang = this.sessionState.getLanguage();
+        if (!existingHeaders?.has('Accept-Language') && lang) {
+            headers['Accept-Language'] = lang;
+        }
+        const tenant = this.sessionState.getTenant();
+        if (!existingHeaders?.has(this.tenantKey) && tenant?.id) {
+            headers[this.tenantKey] = tenant.id;
+        }
+        headers['X-Requested-With'] = 'XMLHttpRequest';
+        return headers;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: OAuthApiInterceptor, deps: [{ token: i1.OAuthService }, { token: i2.SessionStateService }, { token: i2.HttpWaitService }, { token: TENANT_KEY }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: OAuthApiInterceptor, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: OAuthApiInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.OAuthService }, { type: i2.SessionStateService }, { type: i2.HttpWaitService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TENANT_KEY]
                 }] }]; } });
 
-class AbpOAuthGuard {
-    constructor(oauthService, authService) {
-        this.oauthService = oauthService;
-        this.authService = authService;
-    }
-    canActivate() {
-        const hasValidAccessToken = this.oauthService.hasValidAccessToken();
-        if (hasValidAccessToken) {
-            return true;
-        }
-        this.authService.navigateToLogin();
-        return false;
-    }
-}
-AbpOAuthGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthGuard, deps: [{ token: i1.OAuthService }, { token: i2.AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
-AbpOAuthGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthGuard, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthGuard, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return [{ type: i1.OAuthService }, { type: i2.AuthService }]; } });
+class AbpOAuthGuard {
+    constructor() {
+        this.oAuthService = inject(OAuthService);
+        this.authService = inject(AuthService);
+        this.httpErrorReporter = inject(HttpErrorReporterService);
+    }
+    canActivate(route, state) {
+        const hasValidAccessToken = this.oAuthService.hasValidAccessToken();
+        if (hasValidAccessToken) {
+            return true;
+        }
+        return of(false).pipe(tap$1(() => this.httpErrorReporter.reportError({ status: 401 })), delay(1500), tap$1(() => {
+            const params = { returnUrl: state.url };
+            this.authService.navigateToLogin(params);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthGuard, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
 
-const NavigateToManageProfileProvider = {
-    provide: NAVIGATE_TO_MANAGE_PROFILE,
-    useFactory: () => {
-        const environment = inject(EnvironmentService);
-        return () => {
-            const env = environment.getEnvironment();
-            if (!env.oAuthConfig) {
-                console.warn('The oAuthConfig env is missing on environment.ts');
-                return;
-            }
-            const { issuer } = env.oAuthConfig;
-            const path = issuer.endsWith('/') ? issuer : `${issuer}/`;
-            window.open(`${path}Account/Manage?returnUrl=${window.location.href}`, '_self');
-        };
-    },
+const NavigateToManageProfileProvider = {
+    provide: NAVIGATE_TO_MANAGE_PROFILE,
+    useFactory: () => {
+        const environment = inject(EnvironmentService);
+        return () => {
+            const env = environment.getEnvironment();
+            if (!env.oAuthConfig) {
+                console.warn('The oAuthConfig env is missing on environment.ts');
+                return;
+            }
+            const { issuer } = env.oAuthConfig;
+            const path = issuer.endsWith('/') ? issuer : `${issuer}/`;
+            window.open(`${path}Account/Manage?returnUrl=${window.location.href}`, '_self');
+        };
+    },
 };
 
-function storageFactory() {
-    return oAuthStorage;
+function storageFactory() {
+    return oAuthStorage;
 }
 
-const checkAccessToken = function (injector) {
-    const configState = injector.get(ConfigStateService);
-    const oAuth = injector.get(OAuthService);
-    if (oAuth.hasValidAccessToken() && !configState.getDeep('currentUser.id')) {
-        clearOAuthStorage();
-    }
+const checkAccessToken = function (injector) {
+    const configState = injector.get(ConfigStateService);
+    const oAuth = injector.get(OAuthService);
+    if (oAuth.hasValidAccessToken() && !configState.getDeep('currentUser.id')) {
+        clearOAuthStorage();
+    }
 };
 
-class AbpOAuthModule {
-    static forRoot() {
-        return {
-            ngModule: AbpOAuthModule,
-            providers: [
-                {
-                    provide: AuthService,
-                    useClass: AbpOAuthService,
-                },
-                {
-                    provide: AuthGuard,
-                    useClass: AbpOAuthGuard,
-                },
-                {
-                    provide: ApiInterceptor,
-                    useClass: OAuthApiInterceptor,
-                },
-                {
-                    provide: PIPE_TO_LOGIN_FN_KEY,
-                    useValue: pipeToLogin,
-                },
-                {
-                    provide: CHECK_AUTHENTICATION_STATE_FN_KEY,
-                    useValue: checkAccessToken,
-                },
-                {
-                    provide: HTTP_INTERCEPTORS,
-                    useExisting: ApiInterceptor,
-                    multi: true,
-                },
-                NavigateToManageProfileProvider,
-                {
-                    provide: APP_INITIALIZER,
-                    multi: true,
-                    deps: [OAuthConfigurationHandler],
-                    useFactory: noop,
-                },
-                OAuthModule.forRoot().providers,
-                { provide: OAuthStorage, useClass: AbpLocalStorageService },
-            ],
-        };
-    }
-}
-AbpOAuthModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AbpOAuthModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthModule, imports: [CommonModule, OAuthModule] });
-AbpOAuthModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthModule, imports: [CommonModule, OAuthModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [CommonModule, OAuthModule],
-                }]
+class AbpOAuthModule {
+    static forRoot() {
+        return {
+            ngModule: AbpOAuthModule,
+            providers: [
+                {
+                    provide: AuthService,
+                    useClass: AbpOAuthService,
+                },
+                {
+                    provide: AuthGuard,
+                    useClass: AbpOAuthGuard,
+                },
+                {
+                    provide: ApiInterceptor,
+                    useClass: OAuthApiInterceptor,
+                },
+                {
+                    provide: PIPE_TO_LOGIN_FN_KEY,
+                    useValue: pipeToLogin,
+                },
+                {
+                    provide: CHECK_AUTHENTICATION_STATE_FN_KEY,
+                    useValue: checkAccessToken,
+                },
+                {
+                    provide: HTTP_INTERCEPTORS,
+                    useExisting: ApiInterceptor,
+                    multi: true,
+                },
+                NavigateToManageProfileProvider,
+                {
+                    provide: APP_INITIALIZER,
+                    multi: true,
+                    deps: [OAuthConfigurationHandler],
+                    useFactory: noop,
+                },
+                OAuthModule.forRoot().providers,
+                { provide: OAuthStorage, useClass: AbpLocalStorageService },
+            ],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthModule, imports: [CommonModule, OAuthModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthModule, imports: [CommonModule, OAuthModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, OAuthModule],
+                }]
         }] });
 
-/**
- * Generated bundle index. Do not edit.
+/**
+ * Generated bundle index. Do not edit.
  */
 
 export { AUTH_FLOW_STRATEGY, AbpOAuthGuard, AbpOAuthModule, AbpOAuthService, AuthCodeFlowStrategy, AuthFlowStrategy, AuthPasswordFlowStrategy, NavigateToManageProfileProvider, OAuthApiInterceptor, OAuthConfigurationHandler, checkAccessToken, clearOAuthStorage, oAuthStorage, pipeToLogin, removeRememberMe, setRememberMe, storageFactory };