@odx/auth 14.0.0 → 15.0.1

package/esm2022/lib/auth.service.mjs

@@ -9,7 +9,40 @@ import { injectAuthConfig } from './auth.config';
 import { setHttpAuthHeader } from './helpers';
 import { AuthPluginManager } from './models';
 import * as i0 from "@angular/core";
+/**
+ * The `AuthService` class provides authentication functionality for an Angular application.
+ * It handles OAuth2/OIDC authentication, token management, and user identity claims.
+ *
+ * Key responsibilities include:
+ * - Initializing authentication with a provided configuration.
+ * - Managing tokens (access, refresh, and ID tokens).
+ * - Checking and emitting authentication and authorization states.
+ * - Handling user login and logout flows.
+ * - Supporting silent refresh and offline authentication scenarios.
+ * - Integrating authentication plugins via `AuthPluginManager`.
+ *
+ * @example
+ * ```typescript
+ * // Injecting the AuthService
+ * constructor(private authService: AuthService) {}
+ *
+ * // Using the AuthService to initialize authentication
+ * async ngOnInit() {
+ *   const config: AuthConfig = { clientId: 'your-client-id', discoveryUrl: 'https://example.com/.well-known/openid-configuration' };
+ *   await this.authService.initialize(config);
+ * }
+ * ```
+ */
 export class AuthService {
+    /**
+     * Emits whenever the `access_token` in local storage is updated or cleared.
+     * Provides an observable for tracking token updates.
+     *
+     * @type {Observable<StorageEvent | null>}
+     */
+    get accessTokenUpdate$() {
+        return this.onAccessTokenUpdate$;
+    }
     constructor() {
         this.authConfig = injectAuthConfig();
         this.authPluginManager = inject(AuthPluginManager);
@@ -21,16 +54,62 @@ export class AuthService {
         this.onAccessTokenUpdate$ = fromEvent(this.windowRef.nativeWindow, 'storage').pipe(filter(({ key }) => key === 'access_token' || key === null), startWith(null), share());
         this.silentRefreshHandler$ = this.isInitialized$$.pipe(filter(Boolean), switchMap(() => this.windowRef.isOnline$), tap((isOnline) => this.updateSilentRefresh(isOnline)));
         this.onAuthStateChange$ = combineLatest([this.oauthService.events.pipe(startWith(null)), this.windowRef.isOnline$, this.onAccessTokenUpdate$]);
+        /**
+         * Emits `true` when the service has completed initialization.
+         * Emits `false` until the initialization is complete.
+         *
+         * @type {Observable<boolean>}
+         */
         this.isInitialized$ = this.isInitialized$$.pipe(filter(Boolean), distinctUntilChanged());
+        /**
+         * Emits `true` when the user is being redirected to the login page.
+         * Emits `false` when there is no redirection in progress.
+         *
+         * @type {Observable<boolean>}
+         */
         this.isRedirecting$ = this.isRedirecting$$.pipe(distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
+        /**
+         * Emits `true` when the application is in a loading state (e.g., during redirection or plugin initialization).
+         * Emits `false` when there is no ongoing loading activity.
+         *
+         * @type {Observable<boolean>}
+         */
         this.isLoading$ = merge(this.isRedirecting$, this.authPluginManager.pluginsLoading$).pipe(distinctUntilChanged());
+        /**
+         * Emits `true` when the user is authenticated.
+         * Emits `false` when the user is not authenticated.
+         *
+         * @type {Observable<boolean>}
+         */
         this.isAuthenticated$ = this.isInitialized$.pipe(switchMap(() => this.authPluginManager.pluginsReady$), switchMap(() => this.onAuthStateChange$), map(() => this.isAuthenticated()), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
+        /**
+         * Emits the identity claims of the authenticated user.
+         * If the user is not authenticated, emits `null`.
+         *
+         * @type {Observable<OdxAuth.IdentityClaims | null>}
+         */
         this.identityClaims$ = this.isAuthenticated$.pipe(map(() => this.getIdentityClaims()), shareReplay({ bufferSize: 1, refCount: true }));
+        /**
+         * Emits OAuth error events.
+         *
+         * @type {Observable<OAuthErrorEvent>}
+         */
         this.errors$ = this.oauthService.events.pipe(filter((event) => event instanceof OAuthErrorEvent), share());
+        /**
+         * Emits events when an OAuth token is successfully received.
+         *
+         * @type {Observable<Event>}
+         */
         this.onTokenReceived$ = this.oauthService.events.pipe(filter((event) => event.type === 'token_received'), share());
         this.runPlugins();
         this.silentRefreshHandler$.subscribe();
     }
+    /**
+     * Initializes the authentication service with the provided configuration.
+     *
+     * @param {AuthConfig} config - The authentication configuration object.
+     * @returns {Promise<void>} Resolves when initialization is complete.
+     */
     async initialize(config) {
         this.assertAudience(config.clientId);
         this.oauthService.configure({ ...config, openUri: this.redirectToLogin.bind(this) });
@@ -57,57 +136,136 @@ export class AuthService {
         await this.tryLoadUserProfile();
         await this.routeToRequestedUrl();
     }
+    /**
+     * Runs all authentication plugins registered in the `AuthPluginManager`.
+     */
     runPlugins() {
         this.authPluginManager.runPlugins(this).subscribe();
     }
+    /**
+     * Returns the issuer URL for the OAuth server.
+     *
+     * @returns {URL} The issuer URL.
+     */
     getIssuer() {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         return new URL(this.oauthService.issuer);
     }
+    /**
+     * Initiates the login flow for the user. Redirects to the login page.
+     *
+     * @param {string} [url] - The URL to redirect back to after login.
+     */
     signIn(url) {
         this.oauthService.initLoginFlow(url);
     }
+    /**
+     * Logs the user out and clears their tokens.
+     *
+     * @param {boolean} [noRedirect] - If `true`, no redirection occurs after logout.
+     */
     signOut(noRedirect) {
         this.oauthService.logOut(noRedirect || !this.getAccessToken());
     }
+    /**
+     * Attempts to refresh the user's tokens.
+     *
+     * @returns {Promise<TokenResponse>} Resolves with the new token response.
+     */
     async refreshTokens() {
         return this.oauthService.refreshToken();
     }
+    /**
+     * Retrieves the current access token, if available.
+     *
+     * @returns {string | null} The access token, or `null` if not available.
+     */
     getAccessToken() {
         return this.oauthService.getAccessToken() ?? null;
     }
+    /**
+     * Retrieves the current refresh token, if available.
+     *
+     * @returns {string | null} The refresh token, or `null` if not available.
+     */
     getRefreshToken() {
         return this.oauthService.getRefreshToken() ?? null;
     }
+    /**
+     * Retrieves the current ID token, if available.
+     *
+     * @returns {string | null} The ID token, or `null` if not available.
+     */
     getIdToken() {
         return this.oauthService.getIdToken() ?? null;
     }
+    /**
+     * Retrieves the identity claims of the authenticated user.
+     *
+     * @returns {OdxAuth.IdentityClaims | null} The identity claims, or `null` if not available.
+     */
     getIdentityClaims() {
         if (!this.getIdToken())
             return null;
         return deepmerge(this.oauthService.getIdentityClaims(), this.authPluginManager.getResult());
     }
+    /**
+     * Retrieves the raw identity claims of the authenticated user.
+     *
+     * @returns {OdxAuth.RawIdentityClaims | null} The raw identity claims, or `null` if not available.
+     */
     getRawIdentityClaims() {
         if (!this.getIdToken())
             return null;
         return this.oauthService.getIdentityClaims();
     }
+    /**
+     * Checks if the user is currently authenticated.
+     *
+     * @returns {boolean} `true` if authenticated, otherwise `false`.
+     */
     isAuthenticated() {
         if (this.windowRef.isOnline()) {
             return this.oauthService.hasValidAccessToken() && this.oauthService.hasValidIdToken();
         }
         return this.hasValidOfflineToken();
     }
+    /**
+     * Checks if the user is authorized based on the provided handler.
+     *
+     * @param {AuthorizedHandler | null} [authorizedHandler] - A handler to determine authorization.
+     * @returns {boolean} `true` if authorized, otherwise `false`.
+     */
     isAuthorized(authorizedHandler) {
         const handler = authorizedHandler ?? this.authConfig.defaultAuthorizedHandler;
         return this.isAuthenticated() && (handler?.(this.getIdentityClaims(), this, this.router) ?? true);
     }
+    /**
+     * Emits whether the user is authorized based on the provided handler.
+     *
+     * @param {AuthorizedHandler | null} [authorizedHandler] - A handler to determine authorization.
+     * @returns {Observable<boolean>} An observable emitting the authorization status.
+     */
     isAuthorized$(authorizedHandler) {
         return this.isAuthenticated$.pipe(map(() => this.isAuthorized(authorizedHandler)));
     }
+    /**
+     * Prepares an HTTP request by adding the access token to its headers.
+     *
+     * @param {HttpRequest<T> | Request} req - The HTTP request to prepare.
+     * @param {boolean} requireSignIn - Whether to require the user to sign in if no token is available.
+     * @returns {Observable<R>} An observable emitting the prepared request.
+     * @template R, T
+     */
     prepareAuthRequest$(req, requireSignIn = false) {
         return this.waitForAccessToken$(requireSignIn).pipe(map((token) => setHttpAuthHeader(req, token)));
     }
+    /**
+     * Waits for a valid access token to become available.
+     *
+     * @param {boolean} requireSignIn - Whether to require the user to sign in if no token is available.
+     * @returns {Observable<string | null>} An observable emitting the access token.
+     */
     waitForAccessToken$(requireSignIn) {
         const accessToken$ = of(this.getAccessToken()).pipe(filter((token) => !!token && this.isAuthenticated()));
         const waitForAccessToken$ = this.onTokenReceived$.pipe(timeout(this.authConfig.waitForTokenInMs ?? 0), catchError(async () => this.tryRefreshToken().catch(() => null)));
@@ -150,11 +308,11 @@ export class AuthService {
             this.oauthService.stopAutomaticRefresh();
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: AuthService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: AuthService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: AuthService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../libs/auth/src/lib/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpErrorResponse, HttpRequest } from '@angular/common/http';\nimport { Injectable, inject } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { WindowRef } from '@odx/angular';\nimport { AuthConfig, OAuthErrorEvent, OAuthService, TokenResponse } from 'angular-oauth2-oidc';\nimport { deepmerge } from 'deepmerge-ts';\nimport {\n  BehaviorSubject,\n  Observable,\n  catchError,\n  combineLatest,\n  distinctUntilChanged,\n  filter,\n  fromEvent,\n  map,\n  merge,\n  of,\n  share,\n  shareReplay,\n  startWith,\n  switchMap,\n  take,\n  tap,\n  timeout,\n} from 'rxjs';\nimport { injectAuthConfig } from './auth.config';\nimport { setHttpAuthHeader } from './helpers';\nimport { AuthPluginManager, AuthorizedHandler } from './models';\n\n@Injectable({ providedIn: 'root' })\nexport class AuthService {\n  private readonly authConfig = injectAuthConfig();\n  private readonly authPluginManager = inject(AuthPluginManager);\n  private readonly oauthService = inject(OAuthService);\n  private readonly router = inject(Router);\n  private readonly windowRef = inject(WindowRef);\n\n  private readonly isInitialized$$ = new BehaviorSubject(false);\n  private readonly isRedirecting$$ = new BehaviorSubject(false);\n  private readonly onAccessTokenUpdate$ = fromEvent<StorageEvent>(this.windowRef.nativeWindow, 'storage').pipe(\n    filter(({ key }) => key === 'access_token' || key === null),\n    startWith(null),\n    share(),\n  );\n  private readonly silentRefreshHandler$ = this.isInitialized$$.pipe(\n    filter(Boolean),\n    switchMap(() => this.windowRef.isOnline$),\n    tap((isOnline) => this.updateSilentRefresh(isOnline)),\n  );\n  private readonly onAuthStateChange$ = combineLatest([this.oauthService.events.pipe(startWith(null)), this.windowRef.isOnline$, this.onAccessTokenUpdate$]);\n\n  public readonly isInitialized$ = this.isInitialized$$.pipe(filter(Boolean), distinctUntilChanged());\n  public readonly isRedirecting$ = this.isRedirecting$$.pipe(distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));\n  public readonly isLoading$ = merge(this.isRedirecting$, this.authPluginManager.pluginsLoading$).pipe(distinctUntilChanged());\n  public readonly isAuthenticated$ = this.isInitialized$.pipe(\n    switchMap(() => this.authPluginManager.pluginsReady$),\n    switchMap(() => this.onAuthStateChange$),\n    map(() => this.isAuthenticated()),\n    distinctUntilChanged(),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n  public readonly identityClaims$ = this.isAuthenticated$.pipe(\n    map(() => this.getIdentityClaims()),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n  public readonly errors$ = this.oauthService.events.pipe(\n    filter((event): event is OAuthErrorEvent => event instanceof OAuthErrorEvent),\n    share(),\n  );\n  public readonly onTokenReceived$ = this.oauthService.events.pipe(\n    filter((event) => event.type === 'token_received'),\n    share(),\n  );\n\n  constructor() {\n    this.runPlugins();\n    this.silentRefreshHandler$.subscribe();\n  }\n\n  public async initialize(config: AuthConfig): Promise<void> {\n    this.assertAudience(config.clientId);\n    this.oauthService.configure({ ...config, openUri: this.redirectToLogin.bind(this) });\n    try {\n      await this.oauthService.loadDiscoveryDocument(this.authConfig.discoveryUrl);\n      await this.oauthService.tryLogin();\n      if (this.authConfig.refreshTokenOnInit) {\n        await this.tryRefreshToken();\n      }\n    } catch (error) {\n      if (!(error instanceof HttpErrorResponse || error instanceof OAuthErrorEvent)) {\n        throw error;\n      }\n      if (error.type === 'token_refresh_error' || (error instanceof HttpErrorResponse && (error.status === 401 || error.status === 400))) {\n        this.signOut(true);\n        this.signIn(this.windowRef.location.pathname);\n      }\n    }\n    this.isInitialized$$.next(true);\n    if (this.authConfig.requireSignIn && !this.isAuthenticated()) {\n      this.signIn(this.windowRef.location.pathname);\n    }\n    await this.tryLoadUserProfile();\n    await this.routeToRequestedUrl();\n  }\n\n  public runPlugins(): void {\n    this.authPluginManager.runPlugins(this).subscribe();\n  }\n\n  public getIssuer(): URL {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    return new URL(this.oauthService.issuer!);\n  }\n\n  public signIn(url?: string): void {\n    this.oauthService.initLoginFlow(url);\n  }\n\n  public signOut(noRedirect?: boolean): void {\n    this.oauthService.logOut(noRedirect || !this.getAccessToken());\n  }\n\n  public async refreshTokens(): Promise<TokenResponse> {\n    return this.oauthService.refreshToken();\n  }\n\n  public getAccessToken(): string | null {\n    return this.oauthService.getAccessToken() ?? null;\n  }\n\n  public getRefreshToken(): string | null {\n    return this.oauthService.getRefreshToken() ?? null;\n  }\n\n  public getIdToken(): string | null {\n    return this.oauthService.getIdToken() ?? null;\n  }\n\n  public getIdentityClaims(): OdxAuth.IdentiyClaims | null {\n    if (!this.getIdToken()) return null;\n    return deepmerge(this.oauthService.getIdentityClaims(), this.authPluginManager.getResult()) as OdxAuth.IdentiyClaims;\n  }\n\n  public getRawIdentityClaims(): OdxAuth.RawIdentityClaims | null {\n    if (!this.getIdToken()) return null;\n    return this.oauthService.getIdentityClaims();\n  }\n\n  public isAuthenticated(): boolean {\n    if (this.windowRef.isOnline()) {\n      return this.oauthService.hasValidAccessToken() && this.oauthService.hasValidIdToken();\n    }\n    return this.hasValidOfflineToken();\n  }\n\n  public isAuthorized(authorizedHandler?: AuthorizedHandler | null): boolean {\n    const handler = authorizedHandler ?? this.authConfig.defaultAuthorizedHandler;\n\n    return this.isAuthenticated() && (handler?.(this.getIdentityClaims(), this, this.router) ?? true);\n  }\n\n  public isAuthorized$(authorizedHandler?: AuthorizedHandler | null): Observable<boolean> {\n    return this.isAuthenticated$.pipe(map(() => this.isAuthorized(authorizedHandler)));\n  }\n\n  public prepareAuthRequest$<R extends HttpRequest<T> | Request, T>(req: R, requireSignIn = false): Observable<R> {\n    return this.waitForAccessToken$(requireSignIn).pipe(map((token) => setHttpAuthHeader(req, token)));\n  }\n\n  public waitForAccessToken$(requireSignIn: boolean): Observable<string | null> {\n    const accessToken$ = of(this.getAccessToken()).pipe(filter((token) => !!token && this.isAuthenticated()));\n    const waitForAccessToken$ = this.onTokenReceived$.pipe(\n      timeout(this.authConfig.waitForTokenInMs ?? 0),\n      catchError(async () => this.tryRefreshToken().catch(() => null)),\n    );\n\n    return this.isInitialized$.pipe(\n      switchMap(() => merge(accessToken$, waitForAccessToken$)),\n      take(1),\n      map(() => this.getAccessToken()),\n      tap((token) => !token && requireSignIn && this.signIn(this.windowRef.location.pathname)),\n    );\n  }\n\n  private async routeToRequestedUrl(): Promise<void> {\n    if (!this.oauthService.state || !this.oauthService.hasValidAccessToken()) return;\n    await this.router.navigateByUrl(decodeURIComponent(this.oauthService.state));\n  }\n\n  private hasValidOfflineToken(): boolean {\n    const issuedAt = this.getIdentityClaims()?.iat ?? 0;\n\n    return Date.now() - issuedAt * 1000 <= this.authConfig.maxOfflineTime * 1000;\n  }\n\n  private redirectToLogin(uri: string): void {\n    this.windowRef.location.assign(uri);\n    this.isRedirecting$$.next(true);\n  }\n\n  private async tryLoadUserProfile(): Promise<void> {\n    if (!this.authConfig.loadUserProfile || !this.isAuthenticated()) return;\n    await this.oauthService.loadUserProfile().catch(() => null);\n  }\n\n  private async tryRefreshToken(): Promise<void> {\n    if (!this.getRefreshToken()) return;\n    await this.oauthService.refreshToken();\n  }\n\n  private assertAudience(clientId?: string | null): void {\n    const tokenClientId = this.getIdentityClaims()?.aud;\n    if (!clientId || !tokenClientId || clientId === tokenClientId) return;\n    this.signOut(true);\n  }\n\n  private updateSilentRefresh(enabled: boolean) {\n    if (enabled) {\n      this.oauthService.setupAutomaticSilentRefresh();\n    } else {\n      this.oauthService.stopAutomaticRefresh();\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../libs/auth/src/lib/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpErrorResponse, HttpRequest } from '@angular/common/http';\nimport { Injectable, inject } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { WindowRef } from '@odx/angular';\nimport { AuthConfig, OAuthErrorEvent, OAuthService, TokenResponse } from 'angular-oauth2-oidc';\nimport { deepmerge } from 'deepmerge-ts';\nimport {\n  BehaviorSubject,\n  Observable,\n  catchError,\n  combineLatest,\n  distinctUntilChanged,\n  filter,\n  fromEvent,\n  map,\n  merge,\n  of,\n  share,\n  shareReplay,\n  startWith,\n  switchMap,\n  take,\n  tap,\n  timeout,\n} from 'rxjs';\nimport { injectAuthConfig } from './auth.config';\nimport { setHttpAuthHeader } from './helpers';\nimport { AuthPluginManager, AuthorizedHandler } from './models';\n\n/**\n * The `AuthService` class provides authentication functionality for an Angular application.\n * It handles OAuth2/OIDC authentication, token management, and user identity claims.\n *\n * Key responsibilities include:\n * - Initializing authentication with a provided configuration.\n * - Managing tokens (access, refresh, and ID tokens).\n * - Checking and emitting authentication and authorization states.\n * - Handling user login and logout flows.\n * - Supporting silent refresh and offline authentication scenarios.\n * - Integrating authentication plugins via `AuthPluginManager`.\n *\n * @example\n * ```typescript\n * // Injecting the AuthService\n * constructor(private authService: AuthService) {}\n *\n * // Using the AuthService to initialize authentication\n * async ngOnInit() {\n *   const config: AuthConfig = { clientId: 'your-client-id', discoveryUrl: 'https://example.com/.well-known/openid-configuration' };\n *   await this.authService.initialize(config);\n * }\n * ```\n */\n@Injectable({ providedIn: 'root' })\nexport class AuthService {\n  private readonly authConfig = injectAuthConfig();\n  private readonly authPluginManager = inject(AuthPluginManager);\n  private readonly oauthService = inject(OAuthService);\n  private readonly router = inject(Router);\n  private readonly windowRef = inject(WindowRef);\n\n  private readonly isInitialized$$ = new BehaviorSubject(false);\n  private readonly isRedirecting$$ = new BehaviorSubject(false);\n  private readonly onAccessTokenUpdate$ = fromEvent<StorageEvent>(this.windowRef.nativeWindow, 'storage').pipe(\n    filter(({ key }) => key === 'access_token' || key === null),\n    startWith(null),\n    share(),\n  );\n  private readonly silentRefreshHandler$ = this.isInitialized$$.pipe(\n    filter(Boolean),\n    switchMap(() => this.windowRef.isOnline$),\n    tap((isOnline) => this.updateSilentRefresh(isOnline)),\n  );\n  private readonly onAuthStateChange$ = combineLatest([this.oauthService.events.pipe(startWith(null)), this.windowRef.isOnline$, this.onAccessTokenUpdate$]);\n\n  /**\n   * Emits `true` when the service has completed initialization.\n   * Emits `false` until the initialization is complete.\n   *\n   * @type {Observable<boolean>}\n   */\n  public readonly isInitialized$ = this.isInitialized$$.pipe(filter(Boolean), distinctUntilChanged());\n\n  /**\n   * Emits `true` when the user is being redirected to the login page.\n   * Emits `false` when there is no redirection in progress.\n   *\n   * @type {Observable<boolean>}\n   */\n  public readonly isRedirecting$ = this.isRedirecting$$.pipe(distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));\n\n  /**\n   * Emits `true` when the application is in a loading state (e.g., during redirection or plugin initialization).\n   * Emits `false` when there is no ongoing loading activity.\n   *\n   * @type {Observable<boolean>}\n   */\n  public readonly isLoading$ = merge(this.isRedirecting$, this.authPluginManager.pluginsLoading$).pipe(distinctUntilChanged());\n\n  /**\n   * Emits `true` when the user is authenticated.\n   * Emits `false` when the user is not authenticated.\n   *\n   * @type {Observable<boolean>}\n   */\n  public readonly isAuthenticated$ = this.isInitialized$.pipe(\n    switchMap(() => this.authPluginManager.pluginsReady$),\n    switchMap(() => this.onAuthStateChange$),\n    map(() => this.isAuthenticated()),\n    distinctUntilChanged(),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  /**\n   * Emits the identity claims of the authenticated user.\n   * If the user is not authenticated, emits `null`.\n   *\n   * @type {Observable<OdxAuth.IdentityClaims | null>}\n   */\n  public readonly identityClaims$ = this.isAuthenticated$.pipe(\n    map(() => this.getIdentityClaims()),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  /**\n   * Emits OAuth error events.\n   *\n   * @type {Observable<OAuthErrorEvent>}\n   */\n  public readonly errors$ = this.oauthService.events.pipe(\n    filter((event): event is OAuthErrorEvent => event instanceof OAuthErrorEvent),\n    share(),\n  );\n\n  /**\n   * Emits events when an OAuth token is successfully received.\n   *\n   * @type {Observable<Event>}\n   */\n  public readonly onTokenReceived$ = this.oauthService.events.pipe(\n    filter((event) => event.type === 'token_received'),\n    share(),\n  );\n\n  /**\n   * Emits whenever the `access_token` in local storage is updated or cleared.\n   * Provides an observable for tracking token updates.\n   *\n   * @type {Observable<StorageEvent | null>}\n   */\n  public get accessTokenUpdate$(): Observable<StorageEvent | null> {\n    return this.onAccessTokenUpdate$;\n  }\n\n  constructor() {\n    this.runPlugins();\n    this.silentRefreshHandler$.subscribe();\n  }\n\n  /**\n   * Initializes the authentication service with the provided configuration.\n   *\n   * @param {AuthConfig} config - The authentication configuration object.\n   * @returns {Promise<void>} Resolves when initialization is complete.\n   */\n  public async initialize(config: AuthConfig): Promise<void> {\n    this.assertAudience(config.clientId);\n    this.oauthService.configure({ ...config, openUri: this.redirectToLogin.bind(this) });\n    try {\n      await this.oauthService.loadDiscoveryDocument(this.authConfig.discoveryUrl);\n      await this.oauthService.tryLogin();\n      if (this.authConfig.refreshTokenOnInit) {\n        await this.tryRefreshToken();\n      }\n    } catch (error) {\n      if (!(error instanceof HttpErrorResponse || error instanceof OAuthErrorEvent)) {\n        throw error;\n      }\n      if (error.type === 'token_refresh_error' || (error instanceof HttpErrorResponse && (error.status === 401 || error.status === 400))) {\n        this.signOut(true);\n        this.signIn(this.windowRef.location.pathname);\n      }\n    }\n    this.isInitialized$$.next(true);\n    if (this.authConfig.requireSignIn && !this.isAuthenticated()) {\n      this.signIn(this.windowRef.location.pathname);\n    }\n    await this.tryLoadUserProfile();\n    await this.routeToRequestedUrl();\n  }\n\n  /**\n   * Runs all authentication plugins registered in the `AuthPluginManager`.\n   */\n  public runPlugins(): void {\n    this.authPluginManager.runPlugins(this).subscribe();\n  }\n\n  /**\n   * Returns the issuer URL for the OAuth server.\n   *\n   * @returns {URL} The issuer URL.\n   */\n  public getIssuer(): URL {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    return new URL(this.oauthService.issuer!);\n  }\n\n  /**\n   * Initiates the login flow for the user. Redirects to the login page.\n   *\n   * @param {string} [url] - The URL to redirect back to after login.\n   */\n  public signIn(url?: string): void {\n    this.oauthService.initLoginFlow(url);\n  }\n\n  /**\n   * Logs the user out and clears their tokens.\n   *\n   * @param {boolean} [noRedirect] - If `true`, no redirection occurs after logout.\n   */\n  public signOut(noRedirect?: boolean): void {\n    this.oauthService.logOut(noRedirect || !this.getAccessToken());\n  }\n\n  /**\n   * Attempts to refresh the user's tokens.\n   *\n   * @returns {Promise<TokenResponse>} Resolves with the new token response.\n   */\n  public async refreshTokens(): Promise<TokenResponse> {\n    return this.oauthService.refreshToken();\n  }\n\n  /**\n   * Retrieves the current access token, if available.\n   *\n   * @returns {string | null} The access token, or `null` if not available.\n   */\n  public getAccessToken(): string | null {\n    return this.oauthService.getAccessToken() ?? null;\n  }\n\n  /**\n   * Retrieves the current refresh token, if available.\n   *\n   * @returns {string | null} The refresh token, or `null` if not available.\n   */\n  public getRefreshToken(): string | null {\n    return this.oauthService.getRefreshToken() ?? null;\n  }\n\n  /**\n   * Retrieves the current ID token, if available.\n   *\n   * @returns {string | null} The ID token, or `null` if not available.\n   */\n  public getIdToken(): string | null {\n    return this.oauthService.getIdToken() ?? null;\n  }\n\n  /**\n   * Retrieves the identity claims of the authenticated user.\n   *\n   * @returns {OdxAuth.IdentityClaims | null} The identity claims, or `null` if not available.\n   */\n  public getIdentityClaims(): OdxAuth.IdentiyClaims | null {\n    if (!this.getIdToken()) return null;\n    return deepmerge(this.oauthService.getIdentityClaims(), this.authPluginManager.getResult()) as OdxAuth.IdentiyClaims;\n  }\n\n  /**\n   * Retrieves the raw identity claims of the authenticated user.\n   *\n   * @returns {OdxAuth.RawIdentityClaims | null} The raw identity claims, or `null` if not available.\n   */\n  public getRawIdentityClaims(): OdxAuth.RawIdentityClaims | null {\n    if (!this.getIdToken()) return null;\n    return this.oauthService.getIdentityClaims();\n  }\n\n  /**\n   * Checks if the user is currently authenticated.\n   *\n   * @returns {boolean} `true` if authenticated, otherwise `false`.\n   */\n  public isAuthenticated(): boolean {\n    if (this.windowRef.isOnline()) {\n      return this.oauthService.hasValidAccessToken() && this.oauthService.hasValidIdToken();\n    }\n    return this.hasValidOfflineToken();\n  }\n\n  /**\n   * Checks if the user is authorized based on the provided handler.\n   *\n   * @param {AuthorizedHandler | null} [authorizedHandler] - A handler to determine authorization.\n   * @returns {boolean} `true` if authorized, otherwise `false`.\n   */\n  public isAuthorized(authorizedHandler?: AuthorizedHandler | null): boolean {\n    const handler = authorizedHandler ?? this.authConfig.defaultAuthorizedHandler;\n\n    return this.isAuthenticated() && (handler?.(this.getIdentityClaims(), this, this.router) ?? true);\n  }\n\n  /**\n   * Emits whether the user is authorized based on the provided handler.\n   *\n   * @param {AuthorizedHandler | null} [authorizedHandler] - A handler to determine authorization.\n   * @returns {Observable<boolean>} An observable emitting the authorization status.\n   */\n  public isAuthorized$(authorizedHandler?: AuthorizedHandler | null): Observable<boolean> {\n    return this.isAuthenticated$.pipe(map(() => this.isAuthorized(authorizedHandler)));\n  }\n\n  /**\n   * Prepares an HTTP request by adding the access token to its headers.\n   *\n   * @param {HttpRequest<T> | Request} req - The HTTP request to prepare.\n   * @param {boolean} requireSignIn - Whether to require the user to sign in if no token is available.\n   * @returns {Observable<R>} An observable emitting the prepared request.\n   * @template R, T\n   */\n  public prepareAuthRequest$<R extends HttpRequest<T> | Request, T>(req: R, requireSignIn = false): Observable<R> {\n    return this.waitForAccessToken$(requireSignIn).pipe(map((token) => setHttpAuthHeader(req, token)));\n  }\n\n  /**\n   * Waits for a valid access token to become available.\n   *\n   * @param {boolean} requireSignIn - Whether to require the user to sign in if no token is available.\n   * @returns {Observable<string | null>} An observable emitting the access token.\n   */\n  public waitForAccessToken$(requireSignIn: boolean): Observable<string | null> {\n    const accessToken$ = of(this.getAccessToken()).pipe(filter((token) => !!token && this.isAuthenticated()));\n    const waitForAccessToken$ = this.onTokenReceived$.pipe(\n      timeout(this.authConfig.waitForTokenInMs ?? 0),\n      catchError(async () => this.tryRefreshToken().catch(() => null)),\n    );\n\n    return this.isInitialized$.pipe(\n      switchMap(() => merge(accessToken$, waitForAccessToken$)),\n      take(1),\n      map(() => this.getAccessToken()),\n      tap((token) => !token && requireSignIn && this.signIn(this.windowRef.location.pathname)),\n    );\n  }\n\n  private async routeToRequestedUrl(): Promise<void> {\n    if (!this.oauthService.state || !this.oauthService.hasValidAccessToken()) return;\n    await this.router.navigateByUrl(decodeURIComponent(this.oauthService.state));\n  }\n\n  private hasValidOfflineToken(): boolean {\n    const issuedAt = this.getIdentityClaims()?.iat ?? 0;\n\n    return Date.now() - issuedAt * 1000 <= this.authConfig.maxOfflineTime * 1000;\n  }\n\n  private redirectToLogin(uri: string): void {\n    this.windowRef.location.assign(uri);\n    this.isRedirecting$$.next(true);\n  }\n\n  private async tryLoadUserProfile(): Promise<void> {\n    if (!this.authConfig.loadUserProfile || !this.isAuthenticated()) return;\n    await this.oauthService.loadUserProfile().catch(() => null);\n  }\n\n  private async tryRefreshToken(): Promise<void> {\n    if (!this.getRefreshToken()) return;\n    await this.oauthService.refreshToken();\n  }\n\n  private assertAudience(clientId?: string | null): void {\n    const tokenClientId = this.getIdentityClaims()?.aud;\n    if (!clientId || !tokenClientId || clientId === tokenClientId) return;\n    this.signOut(true);\n  }\n\n  private updateSilentRefresh(enabled: boolean) {\n    if (enabled) {\n      this.oauthService.setupAutomaticSilentRefresh();\n    } else {\n      this.oauthService.stopAutomaticRefresh();\n    }\n  }\n}\n"]}

package/esm2022/lib/components/auth-actions/auth-actions.component.mjs

@@ -9,22 +9,31 @@ import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
 import * as i2 from "@odx/angular/components/list";
 import * as i3 from "@odx/angular/components/icon";
+/**
+ * Displays authentication actions.
+ */
 let AuthActionsComponent = class AuthActionsComponent {
     constructor() {
         this.element = injectElement();
+        /**
+         * The identity claims.
+         *
+         * @type {OdxAuth.IdentiyClaims | null}
+         * @default null
+         */
         this.claims = null;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthActionsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: AuthActionsComponent, isStandalone: true, selector: "odx-auth-actions", inputs: { claims: "claims" }, ngImport: i0, template: "<odx-list>\n  @if (claims?.userProfileUrl; as url) {\n    <a data-testid=\"odx-auth-user-profile-link\" odxListItem [href]=\"url\" rel=\"noopener\" target=\"_blank\">\n      <odx-icon name=\"user-administration\" iconSet=\"core\" odxListItemPrefix />\n      {{ 'userProfileLink' | odxTranslate | async }}\n      <odx-icon name=\"link-external\" iconSet=\"core\" size=\"small\" odxListItemSuffix />\n    </a>\n  }\n</odx-list>\n", dependencies: [{ kind: "ngmodule", type: CoreModule }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "ngmodule", type: ListModule }, { kind: "component", type: i2.ListComponent, selector: "odx-list" }, { kind: "component", type: i2.ListItemComponent, selector: "odx-list-item, [odxListItem]", inputs: ["danger", "variant", "muted", "selected"] }, { kind: "component", type: i3.IconComponent, selector: "odx-icon", inputs: ["inline", "size", "name", "iconSet", "identifier"] }, { kind: "pipe", type: TranslatePipe, name: "odxTranslate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: AuthActionsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.12", type: AuthActionsComponent, isStandalone: true, selector: "odx-auth-actions", inputs: { claims: "claims" }, ngImport: i0, template: "<odx-list>\n  @if (claims?.userProfileUrl; as url) {\n    <a data-testid=\"odx-auth-user-profile-link\" odxListItem [href]=\"url\" rel=\"noopener\" target=\"_blank\">\n      <odx-icon name=\"user-administration\" iconSet=\"core\" odxListItemPrefix />\n      {{ 'userProfileLink' | odxTranslate | async }}\n      <odx-icon name=\"link-external\" iconSet=\"core\" size=\"small\" odxListItemSuffix />\n    </a>\n  }\n</odx-list>\n", dependencies: [{ kind: "ngmodule", type: CoreModule }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "ngmodule", type: ListModule }, { kind: "component", type: i2.ListComponent, selector: "odx-list" }, { kind: "component", type: i2.ListItemComponent, selector: "odx-list-item, [odxListItem]", inputs: ["danger", "variant", "muted", "selected"] }, { kind: "component", type: i3.IconComponent, selector: "odx-icon", inputs: ["inline", "size", "name", "iconSet", "identifier"] }, { kind: "pipe", type: TranslatePipe, name: "odxTranslate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
 };
 AuthActionsComponent = __decorate([
     CSSComponent('auth-actions')
 ], AuthActionsComponent);
 export { AuthActionsComponent };
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthActionsComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: AuthActionsComponent, decorators: [{
             type: Component,
             args: [{ standalone: true, selector: 'odx-auth-actions', imports: [CoreModule, ListModule, TranslatePipe], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: "<odx-list>\n  @if (claims?.userProfileUrl; as url) {\n    <a data-testid=\"odx-auth-user-profile-link\" odxListItem [href]=\"url\" rel=\"noopener\" target=\"_blank\">\n      <odx-icon name=\"user-administration\" iconSet=\"core\" odxListItemPrefix />\n      {{ 'userProfileLink' | odxTranslate | async }}\n      <odx-icon name=\"link-external\" iconSet=\"core\" size=\"small\" odxListItemSuffix />\n    </a>\n  }\n</odx-list>\n" }]
         }], propDecorators: { claims: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/auth-loading-screen/auth-loading-screen.component.mjs

@@ -3,7 +3,6 @@ import { CommonModule } from '@angular/common';
 import { ChangeDetectionStrategy, Component, ViewEncapsulation, inject } from '@angular/core';
 import { fadeOut } from '@odx/angular/animations';
 import { DynamicViewDirective } from '@odx/angular/cdk/dynamic-view';
-import { ButtonComponent } from '@odx/angular/components/button';
 import { CircularProgressComponent } from '@odx/angular/components/circular-progress';
 import { IconComponent } from '@odx/angular/components/icon';
 import { LogoDirective } from '@odx/angular/components/logo';
@@ -12,12 +11,25 @@ import { injectAuthConfig } from '../../auth.config';
 import { AuthService } from '../../auth.service';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
+/**
+ * Authentication loading screen.
+ *
+ * This component displays a loading screen with animations and dynamic content
+ * based on the authentication state.
+ */
 export class AuthLoadingScreenComponent {
     constructor() {
         this.authConfig = injectAuthConfig();
         this.icon$ = inject(AuthService).isRedirecting$.pipe(map((isRedirecting) => (isRedirecting ? 'link-external' : 'user')));
     }
     static { this.instance = null; }
+    /**
+     * Initializes the authentication loading screen.
+     *
+     * @param {AuthService} authService - The authentication service.
+     * @param {DynamicViewService} dynamicViewService - The dynamic view service used to create the loading screen.
+     * @static
+     */
     static initialize(authService, dynamicViewService) {
         authService.isLoading$.subscribe((isLoading) => {
             if (isLoading) {
@@ -29,13 +41,13 @@ export class AuthLoadingScreenComponent {
             }
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthLoadingScreenComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: AuthLoadingScreenComponent, isStandalone: true, selector: "div.odx-auth-loading-screen", host: { properties: { "@hostAnimation": "true" } }, ngImport: i0, template: "<div class=\"odx-auth-loading-screen__content\" odxLayout=\"grid 12 horizontal-center vertical-center gap-small\">\n  <odx-logo size=\"large\" />\n  <odx-circular-progress class=\"odx-auth-loading-screen__spinner\" value=\"-1\" size=\"medium\" stroke=\"3\">\n    <odx-icon [name]=\"icon$ | async\" iconSet=\"core\" />\n  </odx-circular-progress>\n  @if (authConfig.loadingScreenMessage; as content) {\n    <p class=\"odx-auth-loading-screen__message\">\n      <ng-template [odxDynamicView]=\"content\" />\n    </p>\n  }\n</div>\n", styles: ["@keyframes odx-auth-loading-screen-animation{0%{opacity:0;transform:translate(-50%,-50%) scale(.9)}to{opacity:1;transform:translate(-50%,-50%)}}.odx-auth-loading-screen{--odx-c-highlight: var(--odx-c-primary);background-color:var(--odx-c-background-content);inset:0;position:fixed;z-index:var(--odx-v-layer-6)}.odx-auth-loading-screen__content{animation:odx-auth-loading-screen-animation .75s ease;left:50%;position:absolute;top:50%;transform:translate(-50%,-50%)}.odx-auth-loading-screen__message{text-align:center}.odx-auth-loading-screen__spinner{position:relative}.odx-auth-loading-screen__spinner .odx-icon{left:50%;position:absolute;top:50%;transform:translate(-50%,-50%)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "component", type: IconComponent, selector: "odx-icon", inputs: ["inline", "size", "name", "iconSet", "identifier"] }, { kind: "directive", type: LogoDirective, selector: "odx-logo", inputs: ["size", "variant"] }, { kind: "component", type: CircularProgressComponent, selector: "odx-circular-progress", inputs: ["stroke", "size", "value"] }, { kind: "directive", type: DynamicViewDirective, selector: "ng-template[odxDynamicView]", inputs: ["odxDynamicView", "odxDynamicViewInjector", "odxDynamicViewContext"] }], animations: [trigger('hostAnimation', [transition(':leave', useAnimation(fadeOut()))])], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: AuthLoadingScreenComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.12", type: AuthLoadingScreenComponent, isStandalone: true, selector: "div.odx-auth-loading-screen", host: { properties: { "@hostAnimation": "true" } }, ngImport: i0, template: "<div class=\"odx-auth-loading-screen__content\" odxLayout=\"grid 12 horizontal-center vertical-center gap-small\">\n  <odx-logo size=\"large\" />\n  <odx-circular-progress class=\"odx-auth-loading-screen__spinner\" value=\"-1\" size=\"medium\" stroke=\"3\">\n    <odx-icon [name]=\"icon$ | async\" iconSet=\"core\" />\n  </odx-circular-progress>\n  @if (authConfig.loadingScreenMessage; as content) {\n    <p class=\"odx-auth-loading-screen__message\">\n      <ng-template [odxDynamicView]=\"content\" />\n    </p>\n  }\n</div>\n", styles: ["@keyframes odx-auth-loading-screen-animation{0%{opacity:0;transform:translate(-50%,-50%) scale(.9)}to{opacity:1;transform:translate(-50%,-50%)}}.odx-auth-loading-screen{--odx-c-highlight: var(--odx-c-primary);background-color:var(--odx-c-background-content);inset:0;position:fixed;z-index:var(--odx-v-layer-6)}.odx-auth-loading-screen__content{animation:odx-auth-loading-screen-animation .75s ease;left:50%;position:absolute;top:50%;transform:translate(-50%,-50%)}.odx-auth-loading-screen__message{text-align:center}.odx-auth-loading-screen__spinner{position:relative}.odx-auth-loading-screen__spinner .odx-icon{left:50%;position:absolute;top:50%;transform:translate(-50%,-50%)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "component", type: IconComponent, selector: "odx-icon", inputs: ["inline", "size", "name", "iconSet", "identifier"] }, { kind: "directive", type: LogoDirective, selector: "odx-logo", inputs: ["size", "variant"] }, { kind: "component", type: CircularProgressComponent, selector: "odx-circular-progress", inputs: ["stroke", "size", "value"] }, { kind: "directive", type: DynamicViewDirective, selector: "ng-template[odxDynamicView]", inputs: ["odxDynamicView", "odxDynamicViewInjector", "odxDynamicViewContext"] }], animations: [trigger('hostAnimation', [transition(':leave', useAnimation(fadeOut()))])], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthLoadingScreenComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: AuthLoadingScreenComponent, decorators: [{
             type: Component,
-            args: [{ standalone: true, selector: 'div.odx-auth-loading-screen', imports: [CommonModule, ButtonComponent, IconComponent, LogoDirective, CircularProgressComponent, DynamicViewDirective], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
+            args: [{ standalone: true, selector: 'div.odx-auth-loading-screen', imports: [CommonModule, IconComponent, LogoDirective, CircularProgressComponent, DynamicViewDirective], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
                         '[@hostAnimation]': 'true',
                     }, animations: [trigger('hostAnimation', [transition(':leave', useAnimation(fadeOut()))])], template: "<div class=\"odx-auth-loading-screen__content\" odxLayout=\"grid 12 horizontal-center vertical-center gap-small\">\n  <odx-logo size=\"large\" />\n  <odx-circular-progress class=\"odx-auth-loading-screen__spinner\" value=\"-1\" size=\"medium\" stroke=\"3\">\n    <odx-icon [name]=\"icon$ | async\" iconSet=\"core\" />\n  </odx-circular-progress>\n  @if (authConfig.loadingScreenMessage; as content) {\n    <p class=\"odx-auth-loading-screen__message\">\n      <ng-template [odxDynamicView]=\"content\" />\n    </p>\n  }\n</div>\n", styles: ["@keyframes odx-auth-loading-screen-animation{0%{opacity:0;transform:translate(-50%,-50%) scale(.9)}to{opacity:1;transform:translate(-50%,-50%)}}.odx-auth-loading-screen{--odx-c-highlight: var(--odx-c-primary);background-color:var(--odx-c-background-content);inset:0;position:fixed;z-index:var(--odx-v-layer-6)}.odx-auth-loading-screen__content{animation:odx-auth-loading-screen-animation .75s ease;left:50%;position:absolute;top:50%;transform:translate(-50%,-50%)}.odx-auth-loading-screen__message{text-align:center}.odx-auth-loading-screen__spinner{position:relative}.odx-auth-loading-screen__spinner .odx-icon{left:50%;position:absolute;top:50%;transform:translate(-50%,-50%)}\n"] }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/auth-action.directive.mjs

@@ -3,6 +3,12 @@ import { LoadingSpinnerDirective } from '@odx/angular/components/loading-spinner
 import { untilDestroyed } from '@odx/angular/utils';
 import { AuthService } from '../auth.service';
 import * as i0 from "@angular/core";
+/**
+ * An abstract directive that integrates with the `LoadingSpinnerDirective` and `AuthService` to manage loading states based on authentication redirection.
+ *
+ * This directive automatically sets the `autoColor` property of the `LoadingSpinnerDirective` to `true` and subscribes to the `isRedirecting$` observable from the `AuthService`.
+ * When `isRedirecting$` emits a value, it updates the `isLoading` property of the `LoadingSpinnerDirective`.
+ */
 export class AuthActionDirective {
     constructor() {
         this.takeUntilDestroyed = untilDestroyed();
@@ -15,10 +21,10 @@ export class AuthActionDirective {
             this.loadingSpinnerDirective.isLoading = isRedirecting;
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthActionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: AuthActionDirective, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: AuthActionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.12", type: AuthActionDirective, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthActionDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: AuthActionDirective, decorators: [{
             type: Directive
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/sign-in.directive.mjs

@@ -1,3 +1,17 @@
+/**
+ * A directive that handles the sign-in action for a button element.
+ *
+ * This directive extends the `AuthActionDirective` and uses the `LoadingSpinnerDirective`
+ * to show a loading spinner during the sign-in process.
+ *
+ * @see {AuthActionDirective}
+ * @see {LoadingSpinnerDirective}
+ *
+ * @example
+ * ```html
+ * <button odxButton odxAuthSignIn (odxAuthSignIn)="onSignIn()">Sign In</button>
+ * ```
+ */
 import { Directive, EventEmitter, HostListener, Output } from '@angular/core';
 import { LoadingSpinnerDirective } from '@odx/angular/components/loading-spinner';
 import { AuthActionDirective } from './auth-action.directive';
@@ -6,6 +20,11 @@ import * as i1 from "@odx/angular/components/loading-spinner";
 export class SignInDirective extends AuthActionDirective {
     constructor() {
         super(...arguments);
+        /**
+         * Emits an event after the sign-in action is completed.
+         *
+         * @type {EventEmitter<void>}
+         */
         // eslint-disable-next-line @angular-eslint/no-output-rename
         this.afterSignIn = new EventEmitter();
     }
@@ -13,10 +32,10 @@ export class SignInDirective extends AuthActionDirective {
         this.authService.signIn();
         this.afterSignIn.next();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SignInDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: SignInDirective, isStandalone: true, selector: "[odxButton][odxAuthSignIn]", outputs: { afterSignIn: "odxAuthSignIn" }, host: { listeners: { "click": "handleClick()" } }, usesInheritance: true, hostDirectives: [{ directive: i1.LoadingSpinnerDirective }], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: SignInDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.12", type: SignInDirective, isStandalone: true, selector: "[odxButton][odxAuthSignIn]", outputs: { afterSignIn: "odxAuthSignIn" }, host: { listeners: { "click": "handleClick()" } }, usesInheritance: true, hostDirectives: [{ directive: i1.LoadingSpinnerDirective }], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SignInDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.12", ngImport: i0, type: SignInDirective, decorators: [{
             type: Directive,
             args: [{
                     standalone: true,
@@ -30,4 +49,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 type: HostListener,
                 args: ['click']
             }] } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbi1pbi5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2F1dGgvc3JjL2xpYi9kaXJlY3RpdmVzL3NpZ24taW4uZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLFlBQVksRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDOUUsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFDbEYsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUJBQXlCLENBQUM7OztBQU85RCxNQUFNLE9BQU8sZUFBZ0IsU0FBUSxtQkFBbUI7SUFMeEQ7O1FBTUUsNERBQTREO1FBRXJELGdCQUFXLEdBQUcsSUFBSSxZQUFZLEVBQVEsQ0FBQztLQU8vQztJQUpvQixXQUFXO1FBQzVCLElBQUksQ0FBQyxXQUFXLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDMUIsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUMxQixDQUFDOytHQVRVLGVBQWU7bUdBQWYsZUFBZTs7NEZBQWYsZUFBZTtrQkFMM0IsU0FBUzttQkFBQztvQkFDVCxVQUFVLEVBQUUsSUFBSTtvQkFDaEIsUUFBUSxFQUFFLDRCQUE0QjtvQkFDdEMsY0FBYyxFQUFFLENBQUMsdUJBQXVCLENBQUM7aUJBQzFDOzhCQUlRLFdBQVc7c0JBRGpCLE1BQU07dUJBQUMsZUFBZTtnQkFJSixXQUFXO3NCQUQ3QixZQUFZO3VCQUFDLE9BQU8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEV2ZW50RW1pdHRlciwgSG9zdExpc3RlbmVyLCBPdXRwdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IExvYWRpbmdTcGlubmVyRGlyZWN0aXZlIH0gZnJvbSAnQG9keC9hbmd1bGFyL2NvbXBvbmVudHMvbG9hZGluZy1zcGlubmVyJztcbmltcG9ydCB7IEF1dGhBY3Rpb25EaXJlY3RpdmUgfSBmcm9tICcuL2F1dGgtYWN0aW9uLmRpcmVjdGl2ZSc7XG5cbkBEaXJlY3RpdmUoe1xuICBzdGFuZGFsb25lOiB0cnVlLFxuICBzZWxlY3RvcjogJ1tvZHhCdXR0b25dW29keEF1dGhTaWduSW5dJyxcbiAgaG9zdERpcmVjdGl2ZXM6IFtMb2FkaW5nU3Bpbm5lckRpcmVjdGl2ZV0sXG59KVxuZXhwb3J0IGNsYXNzIFNpZ25JbkRpcmVjdGl2ZSBleHRlbmRzIEF1dGhBY3Rpb25EaXJlY3RpdmUge1xuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQGFuZ3VsYXItZXNsaW50L25vLW91dHB1dC1yZW5hbWVcbiAgQE91dHB1dCgnb2R4QXV0aFNpZ25JbicpXG4gIHB1YmxpYyBhZnRlclNpZ25JbiA9IG5ldyBFdmVudEVtaXR0ZXI8dm9pZD4oKTtcblxuICBASG9zdExpc3RlbmVyKCdjbGljaycpXG4gIHByb3RlY3RlZCBvdmVycmlkZSBoYW5kbGVDbGljaygpOiB2b2lkIHtcbiAgICB0aGlzLmF1dGhTZXJ2aWNlLnNpZ25JbigpO1xuICAgIHRoaXMuYWZ0ZXJTaWduSW4ubmV4dCgpO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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