ngx-oauth 7.0.1 → 8.0.1

package/fesm2022/ngx-oauth.mjs

@@ -1,15 +1,6 @@
-import * as i3 from '@angular/common/http';
-import { HttpHeaders, HttpClient, HttpBackend, HttpParams } from '@angular/common/http';
-import * as i0 from '@angular/core';
-import { InjectionToken, inject, Injectable, Component, ViewEncapsulation, Input, Output, ContentChild, HostListener } from '@angular/core';
-import { BehaviorSubject, distinctUntilChanged, switchMap, of, ReplaySubject, from, noop, firstValueFrom, throwError, take } from 'rxjs';
-import { shareReplay, map, catchError, filter, switchMap as switchMap$1, tap, concatMap, delay } from 'rxjs/operators';
-import * as i2 from '@angular/common';
-import { CommonModule } from '@angular/common';
-import * as i3$1 from '@angular/forms';
-import { FormsModule } from '@angular/forms';
+import { signal, linkedSignal, makeEnvironmentProviders, provideEnvironmentInitializer, InjectionToken, inject, computed, effect, untracked, resource } from '@angular/core';
+import { jwtVerify, createRemoteJWKSet } from 'jose';
 
-const HEADER_APPLICATION = new HttpHeaders({ 'Content-Type': 'application/x-www-form-urlencoded' });
 var OAuthType;
 (function (OAuthType) {
     OAuthType["RESOURCE"] = "password";
@@ -24,125 +15,389 @@ var OAuthStatus;
     OAuthStatus["DENIED"] = "DENIED";
 })(OAuthStatus || (OAuthStatus = {}));
 
-const OAUTH_CONFIG = new InjectionToken('OAuthConfig');
-class OAuthConfig {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: OAuthConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: OAuthConfig, providedIn: 'root', useFactory: () => inject(OAUTH_CONFIG).reduce((p, c) => ({ ...p, ...c }), defaultOAuthConfig) }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: OAuthConfig, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                    useFactory: () => inject(OAUTH_CONFIG).reduce((p, c) => ({ ...p, ...c }), defaultOAuthConfig)
-                }]
-        }] });
-const provideOAuthConfig = (config = {}) => ({
-    provide: OAUTH_CONFIG,
-    useValue: config,
-    multi: true
-});
-const provideOAuthConfigFactory = (factory, deps) => ({
-    provide: OAUTH_CONFIG,
-    useFactory: factory,
-    deps: deps,
-    multi: true
-});
-const defaultOAuthConfig = {
-    storage: globalThis.localStorage,
-    location: globalThis.location,
+const defaults = {
     storageKey: 'token',
-    ignorePaths: []
+    ignorePaths: [],
+    strictJwt: true
 };
+const oauthConfig = signal(defaults, ...(ngDevMode ? [{ debugName: "oauthConfig" }] : /* istanbul ignore next */ []));
+const config = linkedSignal(() => oauthConfig().config, ...(ngDevMode ? [{ debugName: "config" }] : /* istanbul ignore next */ []));
+const provideOAuthConfig = (cfg = {}) => makeEnvironmentProviders([provideEnvironmentInitializer(() => oauthConfig.set({ ...defaults, ...cfg }))]);
 
-class OAuthHttpClient extends HttpClient {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: OAuthHttpClient, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: OAuthHttpClient, providedIn: 'root', useFactory: () => new HttpClient(inject(HttpBackend)) }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: OAuthHttpClient, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                    useFactory: () => new HttpClient(inject(HttpBackend)),
-                }]
-        }] });
-
-const isExpiredToken = (token) => token && token.expires && Date.now() > token.expires || false;
-class OAuthTokenService {
-    #token$;
-    constructor(authConfig, http) {
-        this.authConfig = authConfig;
-        this.http = http;
-        this.#token$ = new BehaviorSubject(this.saved);
-        this.token$ = this.#token$.pipe(distinctUntilChanged((p, c) => JSON.stringify(p || null) === JSON.stringify(c || null)), shareReplay(1), switchMap(token => !isExpiredToken(token) && of(token) || this.refreshToken(token)));
-        this.type$ = this.token$.pipe(map(token => token?.type), shareReplay(1));
-        this.accessToken$ = this.token$.pipe(map(token => token?.access_token), shareReplay(1));
+const storage = () => {
+    const s = globalThis.localStorage;
+    return typeof s?.getItem === 'function' ? s : undefined;
+};
+const get = (key) => {
+    const value = storage()?.getItem(key);
+    try {
+        return (value && JSON.parse(value)) || undefined;
     }
-    get token() {
-        return this.#token$.value;
+    catch {
+        return undefined;
     }
-    set token(token) {
-        const expiresIn = Number(token.expires_in) || 0;
-        const result = {
-            ...token,
-            ...expiresIn && { expires: Date.now() + expiresIn * 1000 } || {}
-        };
-        this.saved = result;
-        this.#token$.next(result);
+};
+const set = (key, value) => {
+    storage()?.setItem(key, JSON.stringify(value));
+};
+const storageSignal = (keyInput, defaultValue) => {
+    const keyFn = typeof keyInput === 'function' ? keyInput : () => keyInput;
+    const s = signal(get(keyFn()) ?? defaultValue, ...(ngDevMode ? [{ debugName: "s" }] : /* istanbul ignore next */ []));
+    const { set: signalSet, update } = s;
+    s.set = value => {
+        set(keyFn(), value);
+        signalSet(value);
+    };
+    s.update = fn => {
+        update(current => {
+            const next = fn(current);
+            set(keyFn(), next);
+            return next;
+        });
+    };
+    return s;
+};
+
+const HEADERS = { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json' };
+const refresh = async (token, config) => {
+    const { tokenPath, clientId, clientSecret, scope } = config || {};
+    const { refresh_token, type } = token || {};
+    if (!refresh_token || !tokenPath)
+        return token;
+    const result = await fetch(tokenPath, {
+        method: 'POST',
+        headers: HEADERS,
+        body: new URLSearchParams({
+            client_id: clientId,
+            ...((clientSecret && { client_secret: clientSecret }) || {}),
+            grant_type: 'refresh_token',
+            refresh_token,
+            ...((scope && { scope }) || {})
+        })
+    }).then(r => r.json());
+    return result ? { ...result, type } : token;
+};
+const revoke = async (token, config) => {
+    const { revokePath, clientId, clientSecret } = config || {};
+    if (!revokePath)
+        return;
+    const { access_token, refresh_token } = token || {};
+    const base = {
+        ...((clientId && { client_id: clientId }) || {}),
+        ...((clientSecret && { client_secret: clientSecret }) || {})
+    };
+    if (access_token) {
+        await fetch(revokePath, {
+            method: 'POST',
+            headers: HEADERS,
+            body: new URLSearchParams({ ...base, token: access_token, token_type_hint: 'access_token' })
+        });
     }
-    get saved() {
-        const { storageKey, storage } = this.authConfig;
-        return storageKey && storage && storage[storageKey] && JSON.parse(storage[storageKey]) || {};
+    if (refresh_token) {
+        await fetch(revokePath, {
+            method: 'POST',
+            headers: HEADERS,
+            body: new URLSearchParams({ ...base, token: refresh_token, token_type_hint: 'refresh_token' })
+        });
     }
-    set saved(token) {
-        const { storageKey, storage } = this.authConfig;
-        if (storage && storageKey) {
-            if (token) {
-                storage[storageKey] = JSON.stringify(token);
+};
+const authorize = async (token, config) => {
+    const { clientId, clientSecret, tokenPath, scope } = config || {};
+    const { code, redirect_uri, code_verifier } = token || {};
+    if (!code || !tokenPath)
+        return token;
+    const result = await fetch(tokenPath, {
+        method: 'POST',
+        headers: HEADERS,
+        body: new URLSearchParams({
+            code,
+            client_id: clientId,
+            ...((clientSecret && { client_secret: clientSecret }) || {}),
+            redirect_uri: redirect_uri,
+            grant_type: 'authorization_code',
+            ...((scope && { scope }) || {}),
+            ...((code_verifier && { code_verifier }) || {})
+        })
+    }).then(r => r.json());
+    return result ? { ...result, type: OAuthType.AUTHORIZATION_CODE } : token;
+};
+const clientCredentialLogin = async (config) => {
+    const { clientId, clientSecret, tokenPath, scope } = config || {};
+    if (!tokenPath)
+        return undefined;
+    const result = await fetch(tokenPath, {
+        method: 'POST',
+        headers: HEADERS,
+        body: new URLSearchParams({
+            client_id: clientId,
+            client_secret: clientSecret,
+            grant_type: OAuthType.CLIENT_CREDENTIAL,
+            ...(scope ? { scope } : {})
+        })
+    }).then(r => r.json());
+    return result ? { ...result, type: OAuthType.CLIENT_CREDENTIAL } : undefined;
+};
+const resourceOwnerLogin = async (parameters, config) => {
+    const { clientId, clientSecret, tokenPath, scope } = config || {};
+    const { username, password } = parameters || {};
+    if (!tokenPath || !clientId)
+        return undefined;
+    const result = await fetch(tokenPath, {
+        method: 'POST',
+        headers: HEADERS,
+        body: new URLSearchParams({
+            client_id: clientId,
+            ...((clientSecret && { client_secret: clientSecret }) || {}),
+            grant_type: OAuthType.RESOURCE,
+            ...((scope && { scope }) || {}),
+            username: username,
+            password: password
+        })
+    }).then(r => r.json());
+    return result ? { ...result, type: OAuthType.RESOURCE } : undefined;
+};
+const openIdConfiguration = async (config) => {
+    const { issuerPath, clientId } = config || {};
+    if (!issuerPath)
+        return undefined;
+    return fetch(`${issuerPath}/.well-known/openid-configuration?client_id=${clientId}`).then(r => r.json());
+};
+const userInfo = async (config, fetchFn = fetch) => {
+    const { userPath } = config || {};
+    if (!userPath)
+        return undefined;
+    return fetchFn(userPath).then(r => r.json());
+};
+const introspect = async (token, config) => {
+    const { introspectionPath, clientId, clientSecret } = config || {};
+    const { access_token } = token || {};
+    if (!introspectionPath || !access_token || !clientId)
+        return undefined;
+    return fetch(introspectionPath, {
+        method: 'POST',
+        headers: { ...HEADERS, Authorization: `Basic ${btoa(`${clientId}:${clientSecret}`)}` },
+        body: new URLSearchParams({ token: access_token })
+    }).then(r => r.json());
+};
+const OAUTH_REFRESH = new InjectionToken('OAUTH_REFRESH', {
+    providedIn: 'root',
+    factory: () => refresh
+});
+const OAUTH_REVOKE = new InjectionToken('OAUTH_REVOKE', {
+    providedIn: 'root',
+    factory: () => revoke
+});
+const OAUTH_AUTHORIZE = new InjectionToken('OAUTH_AUTHORIZE', {
+    providedIn: 'root',
+    factory: () => authorize
+});
+const OAUTH_CLIENT_CREDENTIAL = new InjectionToken('OAUTH_CLIENT_CREDENTIAL', {
+    providedIn: 'root',
+    factory: () => clientCredentialLogin
+});
+const OAUTH_RESOURCE_OWNER = new InjectionToken('OAUTH_RESOURCE_OWNER', {
+    providedIn: 'root',
+    factory: () => resourceOwnerLogin
+});
+const OAUTH_OPENID_CONFIG = new InjectionToken('OAUTH_OPENID_CONFIG', {
+    providedIn: 'root',
+    factory: () => openIdConfiguration
+});
+const OAUTH_USER_INFO = new InjectionToken('OAUTH_USER_INFO', {
+    providedIn: 'root',
+    factory: () => userInfo
+});
+const OAUTH_INTROSPECT = new InjectionToken('OAUTH_INTROSPECT', {
+    providedIn: 'root',
+    factory: () => introspect
+});
+
+const isExpiredToken = (token) => (token?.expires && Date.now() > token.expires) || false;
+const OAUTH_TOKEN = new InjectionToken('OAUTH_TOKEN', {
+    providedIn: 'root',
+    factory: () => {
+        const refresh = inject(OAUTH_REFRESH);
+        const openIdConfiguration = inject(OAUTH_OPENID_CONFIG);
+        const storageKey = linkedSignal(() => oauthConfig().storageKey, ...(ngDevMode ? [{ debugName: "storageKey" }] : /* istanbul ignore next */ []));
+        const token = storageSignal(storageKey, {});
+        const type = computed(() => token().type, ...(ngDevMode ? [{ debugName: "type" }] : /* istanbul ignore next */ []));
+        const accessToken = computed(() => {
+            const { token_type, access_token } = token() || {};
+            return (token_type && access_token && `${token_type} ${access_token}`) || undefined;
+        }, ...(ngDevMode ? [{ debugName: "accessToken" }] : /* istanbul ignore next */ []));
+        const status = computed(() => {
+            const { error, access_token } = token();
+            return ((error && OAuthStatus.DENIED) || (access_token && !isExpiredToken(token()) && OAuthStatus.AUTHORIZED) || OAuthStatus.NOT_AUTHORIZED);
+        }, ...(ngDevMode ? [{ debugName: "status" }] : /* istanbul ignore next */ []));
+        const isAuthorized = computed(() => status() === OAuthStatus.AUTHORIZED, ...(ngDevMode ? [{ debugName: "isAuthorized" }] : /* istanbul ignore next */ []));
+        const error = computed(() => token().error, ...(ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []));
+        const hasError = computed(() => !!error(), ...(ngDevMode ? [{ debugName: "hasError" }] : /* istanbul ignore next */ []));
+        const errorDescription = computed(() => token().error_description, ...(ngDevMode ? [{ debugName: "errorDescription" }] : /* istanbul ignore next */ []));
+        const autoconfigOauth = async () => {
+            const c = config();
+            if (!(c.tokenPath || c.authorizePath)) {
+                const v = await openIdConfiguration(c);
+                if (v) {
+                    config.set({
+                        ...c,
+                        ...((v?.authorization_endpoint && { authorizePath: v.authorization_endpoint }) || {}),
+                        ...((v?.token_endpoint && { tokenPath: v.token_endpoint }) || {}),
+                        ...((v?.revocation_endpoint && { revokePath: v.revocation_endpoint }) || {}),
+                        ...((v?.userinfo_endpoint && { userPath: v.userinfo_endpoint }) || {}),
+                        ...((v?.introspection_endpoint && { introspectionPath: v.introspection_endpoint }) || {}),
+                        ...((v?.end_session_endpoint && { logoutPath: v.end_session_endpoint }) || {}),
+                        ...((v?.jwks_uri && { jwksUri: v.jwks_uri }) || {}),
+                        ...((c?.pkce === undefined &&
+                            v?.code_challenge_methods_supported && { pkce: v.code_challenge_methods_supported.indexOf('S256') > -1 }) ||
+                            {}),
+                        ...{ scope: c.scope || 'openid' }
+                    });
+                }
             }
-            else {
-                delete storage[storageKey];
+        };
+        const setExpires = (t) => {
+            const expiresIn = Number(t?.expires_in) || 0;
+            if (expiresIn && !t.expires) {
+                token.set({
+                    ...t,
+                    expires: Date.now() + expiresIn * 1000
+                });
             }
-        }
+        };
+        let inFlight;
+        const checkToken = (t) => {
+            if (inFlight)
+                return inFlight;
+            inFlight = (async () => {
+                if (isExpiredToken(t)) {
+                    await autoconfigOauth();
+                    const refreshed = await refresh(t, config());
+                    if (refreshed && !isExpiredToken(refreshed)) {
+                        //keep the refresh token cuz we might not net a new one
+                        setExpires({ refresh_token: t.refresh_token, ...refreshed });
+                    }
+                }
+                else {
+                    setExpires(t);
+                }
+            })().finally(() => (inFlight = undefined));
+            return inFlight;
+        };
+        effect(async () => {
+            const t = token();
+            await untracked(() => checkToken(t));
+        });
+        return {
+            token,
+            type,
+            accessToken,
+            status,
+            isAuthorized,
+            error,
+            hasError,
+            errorDescription,
+            storageKey,
+            checkToken,
+            autoconfigOauth
+        };
     }
-    refreshToken(token) {
-        const { tokenPath, clientId, clientSecret, scope } = this.authConfig.config;
-        const { refresh_token } = token || {};
-        return tokenPath && refresh_token && this.http.post(tokenPath, new HttpParams({
-            fromObject: {
-                client_id: clientId,
-                ...clientSecret && { client_secret: clientSecret } || {},
-                grant_type: 'refresh_token',
-                refresh_token,
-                ...scope && { scope } || {},
+});
+
+const getPath = (input) => input instanceof URL ? input.pathname : input instanceof Request ? new URL(input.url).pathname : input;
+const isPathIgnored = (input) => ignorePaths().some(pattern => pattern.test(getPath(input)));
+const ignorePaths = computed(() => oauthConfig().ignorePaths, ...(ngDevMode ? [{ debugName: "ignorePaths" }] : /* istanbul ignore next */ []));
+const OAUTH_FETCH = new InjectionToken('OAUTH_FETCH', {
+    providedIn: 'root',
+    factory: () => {
+        const { token, accessToken, checkToken } = inject(OAUTH_TOKEN);
+        return async (input, init) => {
+            if (!isPathIgnored(input)) {
+                await checkToken(token());
+                const at = accessToken();
+                if (at) {
+                    const headers = new Headers(init?.headers);
+                    headers.set('Authorization', at);
+                    if (!headers.has('Content-Type'))
+                        headers.set('Content-Type', 'application/json');
+                    const response = await globalThis.fetch(input, { ...init, headers });
+                    if (response.status === 401) {
+                        token.set(await response.json());
+                    }
+                    return response;
+                }
             }
-        }), {
-            headers: HEADER_APPLICATION
-        }).pipe(catchError(() => {
-            this.token = {};
-            return of(this.token);
-        }), map(token => {
-            this.token = {
-                ...this.token,
-                ...token
-            };
-            return this.token;
-        })) || of(token);
+            return globalThis.fetch(input, init);
+        };
+    }
+});
+
+const strictJwt = computed(() => oauthConfig().strictJwt, ...(ngDevMode ? [{ debugName: "strictJwt" }] : /* istanbul ignore next */ []));
+const jwksUri = computed(() => config()?.jwksUri, ...(ngDevMode ? [{ debugName: "jwksUri" }] : /* istanbul ignore next */ []));
+const jwt = (idToken) => {
+    const payload = idToken?.split('.')[1];
+    return payload
+        ? JSON.parse(decodeURIComponent(Array.from(atob(payload))
+            .map(c => `%${`00${c.charCodeAt(0).toString(16)}`.slice(-2)}`)
+            .join('')))
+        : {};
+};
+let jwksSet;
+const verifyJwt = async (idToken) => {
+    if (!idToken)
+        return {};
+    if (!jwksSet)
+        return jwt(idToken);
+    const { issuerPath, clientId } = config() || {};
+    try {
+        const { payload } = await jwtVerify(idToken, jwksSet, {
+            ...(issuerPath && { issuer: issuerPath }),
+            ...(clientId && { audience: clientId })
+        });
+        return payload;
+    }
+    catch {
+        return { error: 'Invalid token' };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: OAuthTokenService, deps: [{ token: OAuthConfig }, { token: OAuthHttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: OAuthTokenService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: OAuthTokenService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: OAuthConfig }, { type: OAuthHttpClient }] });
+};
+const OAUTH_VERIFY_JWT = new InjectionToken('OAUTH_VERIFY_JWT', {
+    providedIn: 'root',
+    factory: () => {
+        effect(() => {
+            const uri = jwksUri();
+            jwksSet = uri && strictJwt() ? createRemoteJWKSet(new URL(uri)) : undefined;
+        });
+        return verifyJwt;
+    }
+});
+
+const OAUTH_USER = new InjectionToken('OAUTH_USER', {
+    providedIn: 'root',
+    factory: () => {
+        const { token, isAuthorized, autoconfigOauth } = inject(OAUTH_TOKEN);
+        const verifyJwt = inject(OAUTH_VERIFY_JWT);
+        const userInfo = inject(OAUTH_USER_INFO);
+        const fetch = inject(OAUTH_FETCH);
+        return resource({
+            params: () => ({
+                idToken: token().id_token,
+                authorized: isAuthorized(),
+                userPath: config()?.userPath
+            }),
+            loader: async ({ params: { idToken, authorized, userPath } }) => {
+                if (idToken)
+                    return verifyJwt(idToken);
+                if (authorized && userPath) {
+                    await autoconfigOauth();
+                    return userInfo({ userPath }, fetch);
+                }
+                return undefined;
+            }
+        });
+    }
+});
 
 const arrToString = (buf) => buf.reduce((s, b) => s + String.fromCharCode(b), '');
-const base64url = (str) => btoa(str)
-    .replace(/\+/g, '-')
-    .replace(/\//g, '_')
-    .replace(/=/g, '');
+const base64url = (str) => btoa(str).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
 const randomString = (length = 48) => {
     const buff = arrToString(crypto.getRandomValues(new Uint8Array(length * 2)));
     return base64url(buff).substring(0, length);
@@ -152,572 +407,135 @@ const pkce = async (value) => {
     return base64url(arrToString(new Uint8Array(buff)));
 };
 const parseOauthUri = (hash) => {
-    const regex = /([^&=]+)=([^&]*)/g;
-    const params = {};
-    let m;
-    // tslint:disable-next-line:no-conditional-assignment
-    while ((m = regex.exec(hash)) !== null) {
-        params[decodeURIComponent(m[1])] = decodeURIComponent(m[2]);
-    }
-    return Object.keys(params).length && params || {};
+    const params = Object.fromEntries(new URLSearchParams(hash));
+    return (Object.keys(params).length && params) || {};
 };
-const jwt = (token) => JSON.parse(atob(token.split('.')[1]));
-class OAuthService {
-    get storageKey() {
-        return this.authConfig.storageKey;
-    }
-    set storageKey(storageKey) {
-        if (storageKey) {
-            this.authConfig.storageKey = storageKey;
-            this.tokenService.token = this.tokenService.saved;
-        }
-    }
-    get token() {
-        return this.tokenService.token;
-    }
-    set token(token) {
-        this.tokenService.token = token;
-    }
-    get config() {
-        return this.authConfig.config;
-    }
-    set config(config) {
-        if (config) {
-            this.authConfig.config = {
-                ...this.authConfig.config,
-                ...config
-            };
-        }
-    }
-    constructor(authConfig, tokenService, http, locationService) {
-        this.authConfig = authConfig;
-        this.tokenService = tokenService;
-        this.http = http;
-        this.locationService = locationService;
-        this.state$ = new ReplaySubject(1);
-        this.config$ = of(this.config).pipe(filter(Boolean), filter(config => !!config?.clientId), map(config => config), switchMap$1(config => !config.issuerPath && of(config) || this.http.get(`${config.issuerPath}/.well-known/openid-configuration?client_id=${config.clientId}`).pipe(tap(v => this.config = {
-            ...v.authorization_endpoint && { authorizePath: v.authorization_endpoint } || {},
-            ...v.token_endpoint && { tokenPath: v.token_endpoint } || {},
-            ...v.revocation_endpoint && { revokePath: v.revocation_endpoint } || {},
-            ...v.code_challenge_methods_supported && { pkce: v.code_challenge_methods_supported.indexOf('S256') > -1 } || {},
-            ...v.userinfo_endpoint && { userPath: v.userinfo_endpoint } || {},
-            ...v.introspection_endpoint && { introspectionPath: v.introspection_endpoint } || {},
-            ...v.end_session_endpoint && { logoutPath: v.end_session_endpoint } || {},
-            ...{ scope: config.scope || 'openid' }
-        }), map(() => this.config))), shareReplay(1));
-        this.token$ = this.config$.pipe(tap(config => {
-            const { hash, search, origin, pathname } = this.authConfig.location || {};
-            const isImplicitRedirect = hash && /(access_token=)|(error=)/.test(hash);
-            const isAuthCodeRedirect = search && /(code=)|(error=)/.test(search) || hash && /(code=)|(error=)/.test(hash);
-            if (isImplicitRedirect) {
-                const parameters = parseOauthUri(hash.substring(1));
-                this.token = {
-                    ...parameters,
-                    type: OAuthType.IMPLICIT,
-                };
-                this.checkResponse(this.token, parameters);
+const OAUTH = new InjectionToken('OAUTH', {
+    providedIn: 'root',
+    factory: () => {
+        const { token, status, type, isAuthorized, storageKey, autoconfigOauth } = inject(OAUTH_TOKEN);
+        const resourceOwnerLogin = inject(OAUTH_RESOURCE_OWNER);
+        const clientCredentialLogin = inject(OAUTH_CLIENT_CREDENTIAL);
+        const revoke = inject(OAUTH_REVOKE);
+        const authorize = inject(OAUTH_AUTHORIZE);
+        const verifyJwt = inject(OAUTH_VERIFY_JWT);
+        const state = signal(undefined, ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
+        const login = async (parameters) => {
+            await autoconfigOauth();
+            if (!!parameters && parameters.password) {
+                token.set((await resourceOwnerLogin(parameters, config())) || {});
             }
-            else if (isAuthCodeRedirect) {
-                const parameters = parseOauthUri(search && search.substring(1) || hash && hash.substring(1) || '');
-                if (!this.checkResponse(this.token, parameters)) {
-                    this.token = parameters;
-                }
-                else {
-                    const newParametersString = this.getCleanedUnSearchParameters();
-                    const { clientId, clientSecret, tokenPath, scope } = config;
-                    const { codeVerifier } = this.token || {}; //should be set by authorizationUrl construction
-                    this.http.post(tokenPath, new HttpParams({
-                        fromObject: {
-                            code: parameters?.['code'],
-                            client_id: clientId,
-                            ...clientSecret && { client_secret: clientSecret } || {},
-                            redirect_uri: `${origin}${pathname}`,
-                            grant_type: 'authorization_code',
-                            ...scope && { scope } || {},
-                            ...codeVerifier && { code_verifier: codeVerifier } || {}
-                        }
-                    }), { headers: HEADER_APPLICATION }).pipe().subscribe(token => {
-                        this.token = {
-                            ...token,
-                            type: OAuthType.AUTHORIZATION_CODE
-                        };
-                        this.locationService.replaceState(`${pathname}${newParametersString}`);
-                    });
-                }
+            else if (!!parameters &&
+                parameters.redirectUri &&
+                parameters.responseType) {
+                await toAuthorizationUrl(parameters);
             }
-        }), switchMap$1(() => this.tokenService.token$), shareReplay(1));
-        this.status$ = this.token$.pipe(map(token => token.access_token && OAuthStatus.AUTHORIZED || token.error && OAuthStatus.DENIED || OAuthStatus.NOT_AUTHORIZED), shareReplay(1));
-        this.userInfo$ = this.status$.pipe(filter(s => s === OAuthStatus.AUTHORIZED), map(() => this.config.userPath), filter(Boolean), switchMap$1(path => this.getUserInfo(path)), shareReplay(1));
-        this.type$ = this.tokenService.type$;
-        this.ignorePaths = this.authConfig.ignorePaths || [];
-    }
-    async login(parameters) {
-        if (!!parameters && parameters.password) {
-            await this.resourceLogin(parameters);
-        }
-        else if (!!parameters && parameters.redirectUri && parameters.responseType) {
-            await this.toAuthorizationUrl(parameters);
-        }
-        else {
-            await this.clientCredentialLogin();
-        }
-    }
-    logout(useLogoutUrl) {
-        this.revoke();
-        this.token = {};
-        const { logoutPath, logoutRedirectUri } = this.authConfig.config;
-        if (useLogoutUrl && logoutPath) {
-            const { origin, pathname } = this.authConfig.location || {};
-            const currentPath = `${origin}${pathname}`;
-            this.authConfig.location?.replace(`${logoutPath}?post_logout_redirect_uri=${logoutRedirectUri || currentPath}`);
-        }
-    }
-    getUserInfo(path) {
-        const { userPath } = this.config;
-        return this.http.get(path || userPath);
-    }
-    revoke() {
-        const { revokePath, clientId, clientSecret } = this.authConfig.config;
-        if (revokePath) {
-            const { access_token, refresh_token } = this.token || {};
-            const toRevoke = [];
-            if (access_token) {
-                toRevoke.push({
-                    ...clientId && { client_id: clientId } || {},
-                    ...clientSecret && { client_secret: clientSecret } || {},
-                    token: access_token,
-                    token_type_hint: 'access_token'
-                });
-            }
-            if (refresh_token) {
-                toRevoke.push({
-                    ...clientId && { client_id: clientId } || {},
-                    ...clientSecret && { client_secret: clientSecret } || {},
-                    token: refresh_token,
-                    token_type_hint: 'refresh_token'
-                });
+            else {
+                token.set((await clientCredentialLogin(config())) || {});
             }
-            from(toRevoke).pipe(concatMap(o => of(o).pipe(delay(300))), // space request to avoid cancellation
-            switchMap$1(o => this.http.post(revokePath, new HttpParams({ fromObject: o })))).subscribe(noop);
-        }
-    }
-    clientCredentialLogin() {
-        const { clientId, clientSecret, tokenPath, scope } = this.authConfig.config;
-        return firstValueFrom(this.http.post(tokenPath, new HttpParams({
-            fromObject: {
-                client_id: clientId,
-                client_secret: clientSecret,
-                grant_type: OAuthType.CLIENT_CREDENTIAL,
-                ...scope ? { scope } : {},
+        };
+        const logout = async (next, state) => {
+            await autoconfigOauth();
+            const { logoutPath, clientId, logoutRedirectUri } = config() || {};
+            const returnUrl = next || logoutRedirectUri;
+            if (returnUrl && logoutPath) {
+                const { id_token } = token();
+                const tokenHint = (id_token && `&id_token_hint=${id_token}`) || '';
+                const stateFwd = (state && `&state=${state}`) || '';
+                const logoutUrl = `${logoutPath}?client_id=${clientId}&post_logout_redirect_uri=${returnUrl}${tokenHint}${stateFwd}`;
+                token.set({});
+                globalThis.location?.replace(logoutUrl);
             }
-        }), { headers: HEADER_APPLICATION }).pipe(catchError((err) => {
-            this.token = err;
-            return throwError(() => err);
-        }), tap(params => {
-            this.token = {
-                ...params,
-                type: OAuthType.CLIENT_CREDENTIAL,
-            };
-        })));
-    }
-    resourceLogin(parameters) {
-        const { clientId, clientSecret, tokenPath, scope } = this.authConfig.config;
-        const { username, password } = parameters;
-        return firstValueFrom(this.http.post(tokenPath, new HttpParams({
-            fromObject: {
-                client_id: clientId,
-                ...clientSecret && { client_secret: clientSecret } || {},
-                grant_type: OAuthType.RESOURCE,
-                ...scope && { scope } || {},
-                username,
-                password
+            else {
+                await revoke(token(), config());
+                token.set({});
             }
-        }), { headers: HEADER_APPLICATION }).pipe(catchError(err => {
-            this.token = err;
-            return throwError(() => err);
-        }), tap(params => {
-            this.token = {
-                ...params,
-                type: OAuthType.RESOURCE,
-            };
-        })));
-    }
-    async toAuthorizationUrl(parameters) {
-        const { config, location } = this.authConfig;
-        let authorizationUrl = `${config.authorizePath}`;
-        authorizationUrl += config.authorizePath.includes('?') && '&' || '?';
-        authorizationUrl += `client_id=${config.clientId}`;
-        authorizationUrl += `&redirect_uri=${encodeURIComponent(parameters.redirectUri)}`;
-        authorizationUrl += `&response_type=${parameters.responseType}`;
-        authorizationUrl += `&scope=${encodeURIComponent(config.scope || '')}`;
-        authorizationUrl += `&state=${encodeURIComponent(parameters.state || '')}`;
-        return location?.replace(`${authorizationUrl}${this.generateNonce(config)}${await this.generateCodeChallenge(config)}`);
-    }
-    async generateCodeChallenge(config) {
-        if (config.pkce) {
-            const codeVerifier = randomString();
-            this.token = { ...this.token, codeVerifier };
-            return `&code_challenge=${await pkce(codeVerifier)}&code_challenge_method=S256`;
-        }
-        return '';
-    }
-    generateNonce(config) {
-        if (config && config.scope && config.scope.indexOf('openid') > -1) {
-            const nonce = randomString(10);
-            this.token = { ...this.token, nonce };
-            return `&nonce=${nonce}`;
-        }
-        return '';
-    }
-    checkResponse(token, parameters) {
-        this.emitState(parameters);
-        this.cleanLocationHash();
-        if (!parameters || parameters['error']) {
-            return false;
-        }
-        if (token && token.nonce && parameters['access_token']) {
-            const jwtToken = jwt(parameters['access_token']);
-            return token.nonce === jwtToken.nonce;
-        }
-        return parameters['access_token'] || parameters['code'];
-    }
-    getCleanedUnSearchParameters() {
-        const { search } = this.authConfig.location || {};
-        let searchString = search && search.substring(1) || '';
-        const hashKeys = ['code', 'state', 'error', 'error_description', 'session_state', 'scope', 'authuser', 'prompt', 'iss'];
-        hashKeys.forEach(hashKey => {
-            const re = new RegExp('&' + hashKey + '(=[^&]*)?|^' + hashKey + '(=[^&]*)?&?');
-            searchString = searchString.replace(re, '');
-        });
-        return searchString.length && `?${searchString}` || '';
-    }
-    cleanLocationHash() {
-        if (this.authConfig.location) {
-            const { hash } = this.authConfig.location;
-            let curHash = hash && hash.substring(1) || '';
-            const hashKeys = [
-                'access_token',
-                'token_type',
-                'expires_in',
-                'scope',
-                'state',
-                'error',
-                'error_description',
-                'session_state',
-                'nonce',
-                'id_token',
-                'code',
-                'iss'
-            ];
-            hashKeys.forEach(hashKey => {
-                const re = new RegExp('&' + hashKey + '(=[^&]*)?|^' + hashKey + '(=[^&]*)?&?');
-                curHash = curHash.replace(re, '');
-            });
-            this.authConfig.location.hash = curHash;
-        }
-    }
-    emitState(parameters) {
-        const { state } = parameters || {};
-        state && this.state$.next(state);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: OAuthService, deps: [{ token: OAuthConfig }, { token: OAuthTokenService }, { token: i3.HttpClient }, { token: i2.Location }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: OAuthService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: OAuthService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: OAuthConfig }, { type: OAuthTokenService }, { type: i3.HttpClient }, { type: i2.Location }] });
-
-const OAuthInterceptor = (req, next) => {
-    const authConfig = inject(OAuthConfig);
-    const tokenService = inject(OAuthTokenService);
-    const isPathExcepted = (req) => {
-        const { ignorePaths } = authConfig || {};
-        if (ignorePaths) {
-            for (const ignorePath of ignorePaths) {
-                try {
-                    if (req.url.match(ignorePath)) {
-                        return true;
-                    }
-                }
-                catch (err) {
+        };
+        const oauthCallback = async (url) => {
+            const checkNonce = async (parameters) => {
+                if (parameters['error'])
+                    return parameters;
+                const payload = await verifyJwt(parameters['id_token']);
+                if (payload?.error || payload?.nonce !== token()?.nonce) {
+                    return { error: payload?.error || 'Invalid nonce' };
                 }
-            }
-        }
-        return false;
-    };
-    return isPathExcepted(req) && next(req) || tokenService.token$.pipe(take(1), map(token => {
-        if (token?.access_token) {
-            req = req.clone({
-                setHeaders: {
-                    Authorization: `${token.token_type} ${token.access_token}`
+                return parameters;
+            };
+            const checkCode = async () => {
+                const parameters = await authorize(token(), config());
+                if (parameters) {
+                    token.set(await checkNonce(parameters));
                 }
-            });
-        }
-        return req;
-    }), switchMap(req => next(req)), catchError((err) => {
-        if (err.status === 401) {
-            tokenService.token = {
-                error: `${err.status}`,
-                error_description: err.message
             };
-        }
-        return throwError(() => err);
-    }));
-};
-
-class OAuthLoginComponent {
-    #redirectUri;
-    #responseType;
-    #i18n;
-    get i18n() {
-        return this.#i18n;
-    }
-    set i18n(i18n) {
-        this.#i18n = {
-            ...this.#i18n,
-            ...i18n
+            const path = (url && new URL(url)) || globalThis.location || {};
+            const { hash, search } = path;
+            const isImplicitRedirect = hash && /(access_token=)|(error=)/.test(hash);
+            const isAuthCodeRedirect = (search && /(code=)|(error=)/.test(search)) || (hash && /(code=)|(error=)/.test(hash));
+            if (isImplicitRedirect) {
+                const parameters = parseOauthUri(hash.substring(1));
+                token.set({
+                    ...(await checkNonce(parameters)),
+                    type: OAuthType.IMPLICIT
+                });
+                state.set(parameters?.['state']);
+            }
+            else if (isAuthCodeRedirect) {
+                const parameters = parseOauthUri(search?.substring(1) || hash?.substring(1));
+                token.set({
+                    ...token(),
+                    ...parameters
+                    // do not set type yet. will be set by authorize function since it is a two-step process
+                });
+                state.set(parameters?.['state']);
+                await autoconfigOauth();
+                await checkCode();
+            }
         };
-    }
-    get redirectUri() {
-        return this.#redirectUri || `${globalThis.location?.origin}${this.locationService.path(true) || '/'}`;
-    }
-    set redirectUri(redirectUri) {
-        if (redirectUri) {
-            this.#redirectUri = redirectUri;
-        }
-    }
-    set responseType(responseType) {
-        if (this.responseType) {
-            this.#responseType = responseType;
-        }
-    }
-    get responseType() {
-        return this.#responseType || this.type;
-    }
-    constructor(oauthService, locationService) {
-        this.oauthService = oauthService;
-        this.locationService = locationService;
-        this.#i18n = {
-            username: 'Username',
-            password: 'Password',
-            submit: 'Sign in',
-            notAuthorized: 'Sign in',
-            authorized: 'Welcome',
-            denied: 'Access Denied. Try again!'
+        const toAuthorizationUrl = async (parameters) => {
+            const { authorizePath, clientId, scope = '', pkce } = config();
+            let authorizationUrl = `${authorizePath}`;
+            authorizationUrl += (authorizePath.includes('?') && '&') || '?';
+            authorizationUrl += `client_id=${clientId}`;
+            token.set({ ...token(), redirect_uri: parameters.redirectUri });
+            authorizationUrl += `&access_type=${parameters.accessType || 'offline'}`;
+            authorizationUrl += `&prompt=${parameters.prompt || ''}`;
+            authorizationUrl += `&redirect_uri=${encodeURIComponent(parameters.redirectUri)}`;
+            authorizationUrl += `&response_type=${parameters.responseType}`;
+            authorizationUrl += `&scope=${encodeURIComponent(scope)}`;
+            authorizationUrl += `&state=${encodeURIComponent(parameters.state || '')}`;
+            authorizationUrl = `${authorizationUrl}${generateNonce(scope)}${await generateCodeChallenge(pkce)}`;
+            return globalThis.location?.replace(authorizationUrl);
         };
-        this.type = OAuthType.RESOURCE;
-        this.useLogoutUrl = false;
-        this.state = '';
-        this.stateChange = this.oauthService.state$.asObservable();
-        this.loginTemplate = null;
-        this.username = '';
-        this.password = '';
-        this.OAuthStatus = OAuthStatus;
-        this.OAuthType = OAuthType;
-        this.collapse = false;
-        this.status$ = this.oauthService.status$.pipe(tap(s => {
-            if (s === OAuthStatus.AUTHORIZED && this.profileName$) {
-                this.profileName$.pipe(take(1)).subscribe(n => this.profileName = n);
+        const generateNonce = (scope) => {
+            if (scope.indexOf('openid') > -1) {
+                const nonce = randomString();
+                token.set({ ...token(), nonce });
+                return `&nonce=${nonce}`;
             }
-            else {
-                const { token } = this.oauthService;
-                const userInfo = token && token.id_token && JSON.parse(atob(token.id_token.split('.')[1])) || {};
-                this.profileName = userInfo.name || userInfo.username || userInfo.email || userInfo.sub || '';
+            return '';
+        };
+        const generateCodeChallenge = async (doPkce) => {
+            if (doPkce) {
+                const code_verifier = randomString();
+                token.set({ ...token(), code_verifier });
+                return `&code_challenge=${await pkce(code_verifier)}&code_challenge_method=S256`;
             }
-        }));
-        this.loginFunction = (p) => this.login(p);
-        this.logoutFunction = () => this.logout();
-    }
-    logout() {
-        this.oauthService.logout(this.useLogoutUrl);
-    }
-    login(parameters) {
-        this.collapse = false;
-        return this.oauthService.login(parameters);
-    }
-    toggleCollapse() {
-        this.collapse = !this.collapse;
-    }
-    keyboardEvent() {
-        this.collapse = false;
+            return '';
+        };
+        return {
+            login,
+            logout,
+            oauthCallback,
+            state,
+            token,
+            status,
+            type,
+            isAuthorized,
+            config,
+            storageKey
+        };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: OAuthLoginComponent, deps: [{ token: OAuthService }, { token: i2.Location }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.3", type: OAuthLoginComponent, isStandalone: true, selector: "oauth-login", inputs: { type: "type", i18n: "i18n", redirectUri: "redirectUri", responseType: "responseType", useLogoutUrl: "useLogoutUrl", state: "state", profileName$: "profileName$" }, outputs: { stateChange: "stateChange" }, host: { listeners: { "window:keydown.escape": "keyboardEvent()" } }, queries: [{ propertyName: "loginTemplate", first: true, predicate: ["login"], descendants: true }], ngImport: i0, template: `
-@if (loginTemplate) {
-  <ng-container
-    [ngTemplateOutlet]="loginTemplate"
-    [ngTemplateOutletContext]="{login: loginFunction, logout: logoutFunction, status: status$ | async}">
-  </ng-container>
-} @else {
-  @if (status$ | async; as status) {
-    @if (type === OAuthType.RESOURCE) {
-      <div class="oauth dropdown text-end {{collapse ? 'show': ''}}">
-        <button class="btn btn-link p-0 dropdown-toggle"
-          (click)="status === OAuthStatus.AUTHORIZED ? logout() : toggleCollapse()">
-          <ng-container *ngTemplateOutlet="message"></ng-container>
-        </button>
-        <div class="dropdown-menu mr-3 {{collapse ? 'show': ''}}">
-          @if (status === OAuthStatus.NOT_AUTHORIZED || status === OAuthStatus.DENIED) {
-            <form class="p-3"
-              #form="ngForm"
-              (submit)="login({username: username, password: password})">
-              <div class="mb-3">
-                <input type="text"
-                  class="form-control"
-                  name="username"
-                  required
-                  [(ngModel)]="username"
-                  [placeholder]="i18n.username">
-                </div>
-                <div class="mb-3">
-                  <input type="password"
-                    class="form-control"
-                    name="password"
-                    required
-                    [(ngModel)]="password"
-                    [placeholder]="i18n.password">
-                  </div>
-                  <div class="text-end">
-                    <button type="submit"
-                      class="btn btn-primary"
-                    [disabled]="form.invalid">{{i18n.submit}}</button>
-                  </div>
-                </form>
-              }
-            </div>
-          </div>
-        } @else {
-          <a role="button"
-            class="oauth"
-            (click)="status === OAuthStatus.AUTHORIZED ? logout() : login({responseType: responseType,  redirectUri: redirectUri, state:state})">
-            <ng-container *ngTemplateOutlet="message"></ng-container>
-          </a>
-        }
-        <ng-template #message>
-          @if (status === OAuthStatus.NOT_AUTHORIZED) {
-            <span class="not-authorized"
-            [innerHTML]="i18n.notAuthorized"></span>
-          }
-          @if (status === OAuthStatus.AUTHORIZED) {
-            <span class="authorized"
-              >
-              <span class="welcome" [innerHTML]="i18n.authorized + '&nbsp;'"></span>
-              <strong class="profile-name"
-              [innerHTML]="profileName"></strong>
-            </span>
-          }
-          @if (status === OAuthStatus.DENIED) {
-            <span class="denied"
-            [innerHTML]="i18n.denied"></span>
-          }
-        </ng-template>
-      }
-    }
-    `, isInline: true, styles: [".oauth .dropdown-menu{left:auto;right:0;box-shadow:0 5px 10px #0003;min-width:250px}.oauth .dropdown-menu:before{content:\"\";display:inline-block;border-left:7px solid transparent;border-right:7px solid transparent;border-bottom:7px solid #ccc;border-bottom-color:#0003;position:absolute;top:-7px;left:auto;right:15px}.oauth .dropdown-menu:after{content:\"\";display:inline-block;border-left:6px solid transparent;border-right:6px solid transparent;border-bottom:6px solid #ffffff;position:absolute;top:-6px;left:auto;right:16px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i3$1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i3$1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i3$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3$1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i3$1.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i3$1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i3$1.NgForm, selector: "form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]", inputs: ["ngFormOptions"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }], encapsulation: i0.ViewEncapsulation.None }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: OAuthLoginComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'oauth-login', standalone: true, imports: [
-                        CommonModule,
-                        FormsModule
-                    ], template: `
-@if (loginTemplate) {
-  <ng-container
-    [ngTemplateOutlet]="loginTemplate"
-    [ngTemplateOutletContext]="{login: loginFunction, logout: logoutFunction, status: status$ | async}">
-  </ng-container>
-} @else {
-  @if (status$ | async; as status) {
-    @if (type === OAuthType.RESOURCE) {
-      <div class="oauth dropdown text-end {{collapse ? 'show': ''}}">
-        <button class="btn btn-link p-0 dropdown-toggle"
-          (click)="status === OAuthStatus.AUTHORIZED ? logout() : toggleCollapse()">
-          <ng-container *ngTemplateOutlet="message"></ng-container>
-        </button>
-        <div class="dropdown-menu mr-3 {{collapse ? 'show': ''}}">
-          @if (status === OAuthStatus.NOT_AUTHORIZED || status === OAuthStatus.DENIED) {
-            <form class="p-3"
-              #form="ngForm"
-              (submit)="login({username: username, password: password})">
-              <div class="mb-3">
-                <input type="text"
-                  class="form-control"
-                  name="username"
-                  required
-                  [(ngModel)]="username"
-                  [placeholder]="i18n.username">
-                </div>
-                <div class="mb-3">
-                  <input type="password"
-                    class="form-control"
-                    name="password"
-                    required
-                    [(ngModel)]="password"
-                    [placeholder]="i18n.password">
-                  </div>
-                  <div class="text-end">
-                    <button type="submit"
-                      class="btn btn-primary"
-                    [disabled]="form.invalid">{{i18n.submit}}</button>
-                  </div>
-                </form>
-              }
-            </div>
-          </div>
-        } @else {
-          <a role="button"
-            class="oauth"
-            (click)="status === OAuthStatus.AUTHORIZED ? logout() : login({responseType: responseType,  redirectUri: redirectUri, state:state})">
-            <ng-container *ngTemplateOutlet="message"></ng-container>
-          </a>
-        }
-        <ng-template #message>
-          @if (status === OAuthStatus.NOT_AUTHORIZED) {
-            <span class="not-authorized"
-            [innerHTML]="i18n.notAuthorized"></span>
-          }
-          @if (status === OAuthStatus.AUTHORIZED) {
-            <span class="authorized"
-              >
-              <span class="welcome" [innerHTML]="i18n.authorized + '&nbsp;'"></span>
-              <strong class="profile-name"
-              [innerHTML]="profileName"></strong>
-            </span>
-          }
-          @if (status === OAuthStatus.DENIED) {
-            <span class="denied"
-            [innerHTML]="i18n.denied"></span>
-          }
-        </ng-template>
-      }
-    }
-    `, encapsulation: ViewEncapsulation.None, styles: [".oauth .dropdown-menu{left:auto;right:0;box-shadow:0 5px 10px #0003;min-width:250px}.oauth .dropdown-menu:before{content:\"\";display:inline-block;border-left:7px solid transparent;border-right:7px solid transparent;border-bottom:7px solid #ccc;border-bottom-color:#0003;position:absolute;top:-7px;left:auto;right:15px}.oauth .dropdown-menu:after{content:\"\";display:inline-block;border-left:6px solid transparent;border-right:6px solid transparent;border-bottom:6px solid #ffffff;position:absolute;top:-6px;left:auto;right:16px}\n"] }]
-        }], ctorParameters: () => [{ type: OAuthService }, { type: i2.Location }], propDecorators: { type: [{
-                type: Input
-            }], i18n: [{
-                type: Input
-            }], redirectUri: [{
-                type: Input
-            }], responseType: [{
-                type: Input
-            }], useLogoutUrl: [{
-                type: Input
-            }], state: [{
-                type: Input
-            }], stateChange: [{
-                type: Output
-            }], profileName$: [{
-                type: Input
-            }], loginTemplate: [{
-                type: ContentChild,
-                args: ['login', { static: false }]
-            }], keyboardEvent: [{
-                type: HostListener,
-                args: ['window:keydown.escape']
-            }] } });
+});
 
 /*
  * Public API Surface of ngx-oauth
@@ -727,5 +545,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { HEADER_APPLICATION, OAUTH_CONFIG, OAuthConfig, OAuthHttpClient, OAuthInterceptor, OAuthLoginComponent, OAuthService, OAuthStatus, OAuthTokenService, OAuthType, defaultOAuthConfig, provideOAuthConfig, provideOAuthConfigFactory };
+export { OAUTH, OAUTH_AUTHORIZE, OAUTH_CLIENT_CREDENTIAL, OAUTH_FETCH, OAUTH_INTROSPECT, OAUTH_OPENID_CONFIG, OAUTH_REFRESH, OAUTH_RESOURCE_OWNER, OAUTH_REVOKE, OAUTH_TOKEN, OAUTH_USER, OAUTH_USER_INFO, OAUTH_VERIFY_JWT, OAuthStatus, OAuthType, provideOAuthConfig };
 //# sourceMappingURL=ngx-oauth.mjs.map