@alfresco/adf-core 8.1.0-16295248176 → 8.1.0-16320806191

package/esm2022/lib/auth/oidc/redirect-auth.service.mjs

@@ -0,0 +1,267 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Inject, Injectable, inject } from '@angular/core';
+import { AuthConfig, AUTH_CONFIG, OAuthErrorEvent, OAuthService, OAuthStorage, OAuthSuccessEvent, OAuthLogger } from 'angular-oauth2-oidc';
+import { JwksValidationHandler } from 'angular-oauth2-oidc-jwks';
+import { from, race, ReplaySubject } from 'rxjs';
+import { distinctUntilChanged, filter, map, shareReplay, switchMap, take } from 'rxjs/operators';
+import { AuthService } from './auth.service';
+import { AUTH_MODULE_CONFIG } from './auth-config';
+import { RetryLoginService } from './retry-login.service';
+import { TimeSyncService } from '../services/time-sync.service';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-oauth2-oidc";
+const isPromise = (value) => value && typeof value.then === 'function';
+export class RedirectAuthService extends AuthService {
+    /**
+     * Get whether the user has valid Id/Access tokens.
+     *
+     * @returns `true` if the user is authenticated, otherwise `false`
+     */
+    get authenticated() {
+        return this.oauthService.hasValidIdToken() && this.oauthService.hasValidAccessToken();
+    }
+    constructor(oauthService, _oauthStorage, authConfig) {
+        super();
+        this.oauthService = oauthService;
+        this._oauthStorage = _oauthStorage;
+        this.authModuleConfig = inject(AUTH_MODULE_CONFIG);
+        this._retryLoginService = inject(RetryLoginService);
+        this._oauthLogger = inject(OAuthLogger);
+        this._timeSyncService = inject(TimeSyncService);
+        this._isDiscoveryDocumentLoadedSubject$ = new ReplaySubject();
+        this.isDiscoveryDocumentLoaded$ = this._isDiscoveryDocumentLoadedSubject$.asObservable();
+        this._loadDiscoveryDocumentPromise = Promise.resolve(false);
+        this.AUTH_STORAGE_ITEMS = [
+            'access_token',
+            'access_token_stored_at',
+            'expires_at',
+            'granted_scopes',
+            'id_token',
+            'id_token_claims_obj',
+            'id_token_expires_at',
+            'id_token_stored_at',
+            'nonce',
+            'PKCE_verifier',
+            'refresh_token',
+            'session_state'
+        ];
+        this.authConfig = authConfig;
+        this.oauthService.clearHashAfterLogin = true;
+        this.oauthService.events.pipe(filter(() => oauthService.showDebugInformation)).subscribe((event) => {
+            if (event instanceof OAuthErrorEvent) {
+                this._oauthLogger.error('OAuthErrorEvent Object:', event);
+            }
+            else {
+                this._oauthLogger.info('OAuthEvent Object:', event);
+            }
+        });
+        this.oauthErrorEvent$ = this.oauthService.events.pipe(filter((event) => event instanceof OAuthErrorEvent), map((event) => event));
+        this.firstOauthErrorEventOccur$ = this.oauthErrorEvent$.pipe(take(1));
+        this.firstOauthErrorEventExcludingTokenRefreshError$ = this.oauthErrorEvent$.pipe(filter((event) => event instanceof OAuthErrorEvent && event.type !== 'token_refresh_error'), take(1));
+        this.secondTokenRefreshErrorEventOccur$ = this.oauthErrorEvent$.pipe(filter((event) => event.type === 'token_refresh_error'), take(2), filter((_, index) => index === 1));
+        this.oauthErrorEventOccurDueToClockOutOfSync$ = this.oauthErrorEvent$.pipe(switchMap(() => this._timeSyncService.checkTimeSync(this.oauthService.clockSkewInSec)), filter((timeSync) => timeSync?.outOfSync), map((timeSync) => new Error(`OAuth error occurred due to local machine clock ${timeSync.localDateTimeISO} being out of sync with server time ${timeSync.serverDateTimeISO}`)), take(1));
+        this.authenticated$ = this.oauthService.events.pipe(map(() => this.authenticated), distinctUntilChanged(), shareReplay(1));
+        this.tokenHasExpiredDueToClockOutOfSync$ = this.oauthService.events.pipe(map(() => !!this.oauthService.getIdentityClaims() && this.tokenHasExpired()), filter((hasExpired) => hasExpired), switchMap(() => this._timeSyncService.checkTimeSync(this.oauthService.clockSkewInSec)), filter((timeSync) => timeSync?.outOfSync), map((timeSync) => new Error(`Token has expired due to local machine clock ${timeSync.localDateTimeISO} being out of sync with server time ${timeSync.serverDateTimeISO}`)), take(1));
+        this.onLogout$ = this.oauthService.events.pipe(filter((event) => event.type === 'logout'), map(() => undefined));
+        this.combinedOAuthErrorsStream$ = race([
+            this.oauthErrorEventOccurDueToClockOutOfSync$,
+            this.firstOauthErrorEventExcludingTokenRefreshError$,
+            this.tokenHasExpiredDueToClockOutOfSync$,
+            this.secondTokenRefreshErrorEventOccur$
+        ]);
+        this.combinedOAuthErrorsStream$.subscribe({
+            next: (res) => {
+                this._oauthLogger.error(res);
+                this.logout();
+            },
+            error: () => { }
+        });
+        this.oauthService.events.pipe(take(1)).subscribe(() => {
+            if (this.oauthService.getAccessToken() && !this.oauthService.hasValidAccessToken()) {
+                if (this.oauthService.showDebugInformation) {
+                    this._oauthLogger.warn('Access token not valid. Removing all auth items from storage');
+                }
+                this.AUTH_STORAGE_ITEMS.map((item) => this._oauthStorage.removeItem(item));
+            }
+        });
+        this.onLogin = this.authenticated$.pipe(filter((authenticated) => authenticated), map(() => undefined));
+        this.onTokenReceived = this.oauthService.events.pipe(filter((event) => event.type === 'token_received'), map(() => undefined));
+        this.idpUnreachable$ = this.oauthService.events.pipe(filter((event) => event.type === 'discovery_document_load_error'), map((event) => event.reason));
+    }
+    init() {
+        if (isPromise(this.authConfig)) {
+            return this.authConfig.then((config) => this.configureAuth(config));
+        }
+        return this.configureAuth(this.authConfig);
+    }
+    logout() {
+        this.oauthService.logOut();
+    }
+    ensureDiscoveryDocument() {
+        this._loadDiscoveryDocumentPromise = this._loadDiscoveryDocumentPromise
+            .catch(() => false)
+            .then((loaded) => {
+            if (!loaded) {
+                return this.oauthService.loadDiscoveryDocument().then(() => true);
+            }
+            return true;
+        });
+        return this._loadDiscoveryDocumentPromise;
+    }
+    login(currentUrl) {
+        let stateKey;
+        if (currentUrl) {
+            const randomValue = window.crypto.getRandomValues(new Uint32Array(1))[0];
+            stateKey = `auth_state_${randomValue}${Date.now()}`;
+            this._oauthStorage.setItem(stateKey, JSON.stringify(currentUrl || {}));
+        }
+        // initLoginFlow will initialize the login flow in either code or implicit depending on the configuration
+        this.ensureDiscoveryDocument().then(() => void this.oauthService.initLoginFlow(stateKey));
+    }
+    baseAuthLogin(username, password) {
+        this.oauthService.useHttpBasicAuth = true;
+        return from(this.oauthService.fetchTokenUsingPasswordFlow(username, password)).pipe(map((response) => {
+            const props = new Map();
+            props.set('id_token', response.id_token);
+            // for backward compatibility we need to set the response in our storage
+            this.oauthService['storeAccessTokenResponse'](response.access_token, response.refresh_token, response.expires_in, response.scope, props);
+            return response;
+        }));
+    }
+    async loginCallback(loginOptions) {
+        return this.ensureDiscoveryDocument()
+            .then(() => this._retryLoginService.tryToLoginTimes({
+            ...loginOptions,
+            preventClearHashAfterLogin: this.authModuleConfig.preventClearHashAfterLogin
+        }))
+            .then(() => this._getRedirectUrl());
+    }
+    _getRedirectUrl() {
+        const DEFAULT_REDIRECT = '/';
+        const stateKey = this.oauthService.state;
+        if (stateKey) {
+            const stateStringified = this._oauthStorage.getItem(stateKey);
+            if (stateStringified) {
+                // cleanup state from storage
+                this._oauthStorage.removeItem(stateKey);
+                return JSON.parse(stateStringified);
+            }
+        }
+        return DEFAULT_REDIRECT;
+    }
+    configureAuth(config) {
+        this.oauthService.configure(config);
+        this.oauthService.tokenValidationHandler = new JwksValidationHandler();
+        if (config.sessionChecksEnabled) {
+            this.oauthService.events.pipe(filter((event) => event.type === 'session_terminated')).subscribe(() => {
+                this.oauthService.logOut();
+            });
+        }
+        return this.ensureDiscoveryDocument()
+            .then(() => {
+            this._isDiscoveryDocumentLoadedSubject$.next(true);
+            this.oauthService.setupAutomaticSilentRefresh();
+            return void this.allowRefreshTokenAndSilentRefreshOnMultipleTabs();
+        })
+            .catch(() => {
+            // catch error to prevent the app from crashing when trying to access unprotected routes
+        });
+    }
+    /**
+     * Fix a known issue (https://github.com/manfredsteyer/angular-oauth2-oidc/issues/850)
+     * where multiple tabs can cause the token refresh and the silent refresh to fail.
+     * This patch is based on the solutions provided in the following comments:
+     * https://github.com/manfredsteyer/angular-oauth2-oidc/issues/850#issuecomment-889921776 fix silent refresh for the implicit flow
+     * https://github.com/manfredsteyer/angular-oauth2-oidc/issues/850#issuecomment-1557286966 fix refresh token for the code flow
+     */
+    allowRefreshTokenAndSilentRefreshOnMultipleTabs() {
+        let lastUpdatedAccessToken;
+        if (this.oauthService.hasValidAccessToken()) {
+            lastUpdatedAccessToken = this.oauthService.getAccessToken();
+        }
+        const originalRefreshToken = this.oauthService.refreshToken.bind(this.oauthService);
+        this.oauthService.refreshToken = () => navigator.locks.request(`refresh_tokens_${location.origin}`, () => {
+            if (!!lastUpdatedAccessToken && lastUpdatedAccessToken !== this.oauthService.getAccessToken()) {
+                this.oauthService.eventsSubject.next(new OAuthSuccessEvent('token_received'));
+                this.oauthService.eventsSubject.next(new OAuthSuccessEvent('token_refreshed'));
+                lastUpdatedAccessToken = this.oauthService.getAccessToken();
+                return;
+            }
+            return originalRefreshToken().then((resp) => (lastUpdatedAccessToken = resp.access_token));
+        });
+        const originalSilentRefresh = this.oauthService.silentRefresh.bind(this.oauthService);
+        this.oauthService.silentRefresh = async (params = {}, noPrompt = true) => navigator.locks.request(`silent_refresh_${location.origin}`, async () => {
+            if (lastUpdatedAccessToken !== this.oauthService.getAccessToken()) {
+                this.oauthService.eventsSubject.next(new OAuthSuccessEvent('token_received'));
+                this.oauthService.eventsSubject.next(new OAuthSuccessEvent('token_refreshed'));
+                const event = new OAuthSuccessEvent('silently_refreshed');
+                this.oauthService.eventsSubject.next(event);
+                lastUpdatedAccessToken = this.oauthService.getAccessToken();
+                return event;
+            }
+            else {
+                return originalSilentRefresh(params, noPrompt);
+            }
+        });
+    }
+    updateIDPConfiguration(config) {
+        this.oauthService.configure(config);
+    }
+    /**
+     * Checks if the token has expired.
+     *
+     * This method retrieves the identity claims from the OAuth service and calculates
+     * the token's issued and expiration times. It then compares the current time with
+     * these values, considering a clock skew and a configurable expiration decrease.
+     *
+     * @returns - Returns `true` if the token has expired, otherwise `false`.
+     */
+    tokenHasExpired() {
+        const claims = this.oauthService.getIdentityClaims();
+        if (!claims) {
+            this._oauthLogger.warn('No claims found in the token');
+            return false;
+        }
+        const now = Date.now();
+        const issuedAtMSec = claims.iat * 1000;
+        const expiresAtMSec = claims.exp * 1000;
+        const clockSkewInMSec = this.oauthService.clockSkewInSec * 1000;
+        this.showTokenExpiredDebugInformations(now, issuedAtMSec, expiresAtMSec, clockSkewInMSec);
+        return issuedAtMSec - clockSkewInMSec >= now || expiresAtMSec + clockSkewInMSec - this.oauthService.decreaseExpirationBySec <= now;
+    }
+    showTokenExpiredDebugInformations(now, issuedAtMSec, expiresAtMSec, clockSkewInMSec) {
+        if (this.oauthService.showDebugInformation) {
+            this._oauthLogger.warn('now: ', new Date(now));
+            this._oauthLogger.warn('issuedAt: ', new Date(issuedAtMSec));
+            this._oauthLogger.warn('expiresAt: ', new Date(expiresAtMSec));
+            this._oauthLogger.warn('clockSkewInMSec: ', clockSkewInMSec);
+            this._oauthLogger.warn('this.oauthService.decreaseExpirationBySec: ', this.oauthService.decreaseExpirationBySec);
+            this._oauthLogger.warn('issuedAtMSec - clockSkewInMSec >= now: ', issuedAtMSec - clockSkewInMSec >= now);
+            this._oauthLogger.warn('expiresAtMSec + clockSkewInMSec - this.oauthService.decreaseExpirationBySec <= now: ', expiresAtMSec + clockSkewInMSec - this.oauthService.decreaseExpirationBySec <= now);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RedirectAuthService, deps: [{ token: i1.OAuthService }, { token: i1.OAuthStorage }, { token: AUTH_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RedirectAuthService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RedirectAuthService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.OAuthService }, { type: i1.OAuthStorage }, { type: i1.AuthConfig, decorators: [{
+                    type: Inject,
+                    args: [AUTH_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redirect-auth.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/auth/oidc/redirect-auth.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EACH,UAAU,EACV,WAAW,EACX,eAAe,EAEf,YAAY,EACZ,YAAY,EAGZ,iBAAiB,EACjB,WAAW,EACd,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,IAAI,EAAc,IAAI,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACjG,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAoB,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;;;AAEhE,MAAM,SAAS,GAAG,CAAI,KAAqB,EAAuB,EAAE,CAAC,KAAK,IAAI,OAAQ,KAAoB,CAAC,IAAI,KAAK,UAAU,CAAC;AAG/H,MAAM,OAAO,mBAAoB,SAAQ,WAAW;IAuEhD;;;;OAIG;IACH,IAAI,aAAa;QACb,OAAO,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE,IAAI,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,CAAC;IAC1F,CAAC;IAmBD,YAAoB,YAA0B,EAAU,aAA2B,EAAuB,UAAsB;QAC5H,KAAK,EAAE,CAAC;QADQ,iBAAY,GAAZ,YAAY,CAAc;QAAU,kBAAa,GAAb,aAAa,CAAc;QAhG1E,qBAAgB,GAAqB,MAAM,CAAC,kBAAkB,CAAC,CAAC;QACxD,uBAAkB,GAAsB,MAAM,CAAC,iBAAiB,CAAC,CAAC;QAClE,iBAAY,GAAgB,MAAM,CAAC,WAAW,CAAC,CAAC;QAChD,qBAAgB,GAAoB,MAAM,CAAC,eAAe,CAAC,CAAC;QAErE,uCAAkC,GAAG,IAAI,aAAa,EAAW,CAAC;QACnE,+BAA0B,GAAG,IAAI,CAAC,kCAAkC,CAAC,YAAY,EAAE,CAAC;QAMnF,kCAA6B,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAqE9C,uBAAkB,GAAa;YAC5C,cAAc;YACd,wBAAwB;YACxB,YAAY;YACZ,gBAAgB;YAChB,UAAU;YACV,qBAAqB;YACrB,qBAAqB;YACrB,oBAAoB;YACpB,OAAO;YACP,eAAe;YACf,eAAe;YACf,eAAe;SAClB,CAAC;QAKE,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAE7B,IAAI,CAAC,YAAY,CAAC,mBAAmB,GAAG,IAAI,CAAC;QAE7C,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;YAC/F,IAAI,KAAK,YAAY,eAAe,EAAE,CAAC;gBACnC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,yBAAyB,EAAE,KAAK,CAAC,CAAC;YAC9D,CAAC;iBAAM,CAAC;gBACJ,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,oBAAoB,EAAE,KAAK,CAAC,CAAC;YACxD,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CACjD,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,YAAY,eAAe,CAAC,EACnD,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAwB,CAAC,CAC3C,CAAC;QAEF,IAAI,CAAC,0BAA0B,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAEtE,IAAI,CAAC,+CAA+C,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAC7E,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,YAAY,eAAe,IAAI,KAAK,CAAC,IAAI,KAAK,qBAAqB,CAAC,EAC3F,IAAI,CAAC,CAAC,CAAC,CACV,CAAC;QAEF,IAAI,CAAC,kCAAkC,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAChE,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,qBAAqB,CAAC,EACvD,IAAI,CAAC,CAAC,CAAC,EACP,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,CAAC,CAAC,CACpC,CAAC;QAEF,IAAI,CAAC,wCAAwC,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CACtE,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC,EACtF,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,EAAE,SAAS,CAAC,EACzC,GAAG,CACC,CAAC,QAAQ,EAAE,EAAE,CACT,IAAI,KAAK,CACL,mDAAmD,QAAQ,CAAC,gBAAgB,uCAAuC,QAAQ,CAAC,iBAAiB,EAAE,CAClJ,CACR,EACD,IAAI,CAAC,CAAC,CAAC,CACV,CAAC;QAEF,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAC/C,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,EAC7B,oBAAoB,EAAE,EACtB,WAAW,CAAC,CAAC,CAAC,CACjB,CAAC;QAEF,IAAI,CAAC,mCAAmC,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CACpE,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,iBAAiB,EAAE,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC,EAC5E,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,EAClC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC,EACtF,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,EAAE,SAAS,CAAC,EACzC,GAAG,CACC,CAAC,QAAQ,EAAE,EAAE,CACT,IAAI,KAAK,CACL,gDAAgD,QAAQ,CAAC,gBAAgB,uCAAuC,QAAQ,CAAC,iBAAiB,EAAE,CAC/I,CACR,EACD,IAAI,CAAC,CAAC,CAAC,CACV,CAAC;QAEF,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAC1C,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,EAC1C,GAAG,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CACvB,CAAC;QAEF,IAAI,CAAC,0BAA0B,GAAG,IAAI,CAAC;YACnC,IAAI,CAAC,wCAAwC;YAC7C,IAAI,CAAC,+CAA+C;YACpD,IAAI,CAAC,mCAAmC;YACxC,IAAI,CAAC,kCAAkC;SAC1C,CAAC,CAAC;QAEH,IAAI,CAAC,0BAA0B,CAAC,SAAS,CAAC;YACtC,IAAI,EAAE,CAAC,GAAG,EAAE,EAAE;gBACV,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC7B,IAAI,CAAC,MAAM,EAAE,CAAC;YAClB,CAAC;YACD,KAAK,EAAE,GAAG,EAAE,GAAE,CAAC;SAClB,CAAC,CAAC;QAEH,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YAClD,IAAI,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,EAAE,CAAC;gBACjF,IAAI,IAAI,CAAC,YAAY,CAAC,oBAAoB,EAAE,CAAC;oBACzC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,8DAA8D,CAAC,CAAC;gBAC3F,CAAC;gBACD,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,IAAY,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;YACvF,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CACnC,MAAM,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,aAAa,CAAC,EACxC,GAAG,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CACvB,CAAC;QAEF,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAChD,MAAM,CAAC,CAAC,KAAiB,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,gBAAgB,CAAC,EAC9D,GAAG,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CACvB,CAAC;QAEF,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAChD,MAAM,CAAC,CAAC,KAAK,EAA4B,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,+BAA+B,CAAC,EAC3F,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAe,CAAC,CACxC,CAAC;IACN,CAAC;IAED,IAAI;QACA,IAAI,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC;QACxE,CAAC;QAED,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC/C,CAAC;IAED,MAAM;QACF,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC;IAC/B,CAAC;IAED,uBAAuB;QACnB,IAAI,CAAC,6BAA6B,GAAG,IAAI,CAAC,6BAA6B;aAClE,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC;aAClB,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YACb,IAAI,CAAC,MAAM,EAAE,CAAC;gBACV,OAAO,IAAI,CAAC,YAAY,CAAC,qBAAqB,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;YACtE,CAAC;YACD,OAAO,IAAI,CAAC;QAChB,CAAC,CAAC,CAAC;QACP,OAAO,IAAI,CAAC,6BAA6B,CAAC;IAC9C,CAAC;IAED,KAAK,CAAC,UAAmB;QACrB,IAAI,QAA4B,CAAC;QAEjC,IAAI,UAAU,EAAE,CAAC;YACb,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACzE,QAAQ,GAAG,cAAc,WAAW,GAAG,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;YACpD,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,CAAC;QAC3E,CAAC;QAED,yGAAyG;QACzG,IAAI,CAAC,uBAAuB,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC9F,CAAC;IAED,aAAa,CAAC,QAAgB,EAAE,QAAgB;QAC5C,IAAI,CAAC,YAAY,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAE1C,OAAO,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,2BAA2B,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,CAC/E,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE;YACb,MAAM,KAAK,GAAG,IAAI,GAAG,EAAkB,CAAC;YACxC,KAAK,CAAC,GAAG,CAAC,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;YACzC,wEAAwE;YACxE,IAAI,CAAC,YAAY,CAAC,0BAA0B,CAAC,CACzC,QAAQ,CAAC,YAAY,EACrB,QAAQ,CAAC,aAAa,EACtB,QAAQ,CAAC,UAAU,EACnB,QAAQ,CAAC,KAAK,EACd,KAAK,CACR,CAAC;YACF,OAAO,QAAQ,CAAC;QACpB,CAAC,CAAC,CACL,CAAC;IACN,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,YAA2B;QAC3C,OAAO,IAAI,CAAC,uBAAuB,EAAE;aAChC,IAAI,CAAC,GAAG,EAAE,CACP,IAAI,CAAC,kBAAkB,CAAC,eAAe,CAAC;YACpC,GAAG,YAAY;YACf,0BAA0B,EAAE,IAAI,CAAC,gBAAgB,CAAC,0BAA0B;SAC/E,CAAC,CACL;aACA,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;IAC5C,CAAC;IAEO,eAAe;QACnB,MAAM,gBAAgB,GAAG,GAAG,CAAC;QAC7B,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;QAEzC,IAAI,QAAQ,EAAE,CAAC;YACX,MAAM,gBAAgB,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;YAC9D,IAAI,gBAAgB,EAAE,CAAC;gBACnB,6BAA6B;gBAC7B,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;gBACxC,OAAO,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;YACxC,CAAC;QACL,CAAC;QAED,OAAO,gBAAgB,CAAC;IAC5B,CAAC;IAEO,aAAa,CAAC,MAAkB;QACpC,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QACpC,IAAI,CAAC,YAAY,CAAC,sBAAsB,GAAG,IAAI,qBAAqB,EAAE,CAAC;QAEvE,IAAI,MAAM,CAAC,oBAAoB,EAAE,CAAC;YAC9B,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,oBAAoB,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;gBACjG,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC;YAC/B,CAAC,CAAC,CAAC;QACP,CAAC;QAED,OAAO,IAAI,CAAC,uBAAuB,EAAE;aAChC,IAAI,CAAC,GAAG,EAAE;YACP,IAAI,CAAC,kCAAkC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACnD,IAAI,CAAC,YAAY,CAAC,2BAA2B,EAAE,CAAC;YAChD,OAAO,KAAK,IAAI,CAAC,+CAA+C,EAAE,CAAC;QACvE,CAAC,CAAC;aACD,KAAK,CAAC,GAAG,EAAE;YACR,wFAAwF;QAC5F,CAAC,CAAC,CAAC;IACX,CAAC;IAED;;;;;;OAMG;IACK,+CAA+C;QACnD,IAAI,sBAA0C,CAAC;QAE/C,IAAI,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,EAAE,CAAC;YAC1C,sBAAsB,GAAG,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC;QAChE,CAAC;QAED,MAAM,oBAAoB,GAAG,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACpF,IAAI,CAAC,YAAY,CAAC,YAAY,GAAG,GAA2B,EAAE,CAC1D,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,kBAAkB,QAAQ,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE;YAC9D,IAAI,CAAC,CAAC,sBAAsB,IAAI,sBAAsB,KAAK,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,EAAE,CAAC;gBAC3F,IAAI,CAAC,YAAoB,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,iBAAiB,CAAC,gBAAgB,CAAC,CAAC,CAAC;gBACtF,IAAI,CAAC,YAAoB,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,iBAAiB,CAAC,iBAAiB,CAAC,CAAC,CAAC;gBACxF,sBAAsB,GAAG,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC;gBAC5D,OAAO;YACX,CAAC;YAED,OAAO,oBAAoB,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,sBAAsB,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;QAC/F,CAAC,CAAC,CAAC;QAEP,MAAM,qBAAqB,GAAG,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACtF,IAAI,CAAC,YAAY,CAAC,aAAa,GAAG,KAAK,EAAE,SAAc,EAAE,EAAE,QAAQ,GAAG,IAAI,EAAuB,EAAE,CAC/F,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,kBAAkB,QAAQ,CAAC,MAAM,EAAE,EAAE,KAAK,IAAyB,EAAE;YACzF,IAAI,sBAAsB,KAAK,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,EAAE,CAAC;gBAC/D,IAAI,CAAC,YAAoB,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,iBAAiB,CAAC,gBAAgB,CAAC,CAAC,CAAC;gBACtF,IAAI,CAAC,YAAoB,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,iBAAiB,CAAC,iBAAiB,CAAC,CAAC,CAAC;gBACxF,MAAM,KAAK,GAAG,IAAI,iBAAiB,CAAC,oBAAoB,CAAC,CAAC;gBACzD,IAAI,CAAC,YAAoB,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACrD,sBAAsB,GAAG,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC;gBAC5D,OAAO,KAAK,CAAC;YACjB,CAAC;iBAAM,CAAC;gBACJ,OAAO,qBAAqB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YACnD,CAAC;QACL,CAAC,CAAC,CAAC;IACX,CAAC;IAED,sBAAsB,CAAC,MAAkB;QACrC,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC;IAED;;;;;;;;OAQG;IACH,eAAe;QACX,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,iBAAiB,EAAE,CAAC;QACrD,IAAI,CAAC,MAAM,EAAE,CAAC;YACV,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;YACvD,OAAO,KAAK,CAAC;QACjB,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,MAAM,YAAY,GAAG,MAAM,CAAC,GAAG,GAAG,IAAI,CAAC;QACvC,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,GAAG,IAAI,CAAC;QACxC,MAAM,eAAe,GAAG,IAAI,CAAC,YAAY,CAAC,cAAc,GAAG,IAAI,CAAC;QAEhE,IAAI,CAAC,iCAAiC,CAAC,GAAG,EAAE,YAAY,EAAE,aAAa,EAAE,eAAe,CAAC,CAAC;QAC1F,OAAO,YAAY,GAAG,eAAe,IAAI,GAAG,IAAI,aAAa,GAAG,eAAe,GAAG,IAAI,CAAC,YAAY,CAAC,uBAAuB,IAAI,GAAG,CAAC;IACvI,CAAC;IAEO,iCAAiC,CAAC,GAAW,EAAE,YAAoB,EAAE,aAAqB,EAAE,eAAuB;QACvH,IAAI,IAAI,CAAC,YAAY,CAAC,oBAAoB,EAAE,CAAC;YACzC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;YAC/C,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;YAC7D,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;YAC/D,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC,CAAC;YAC7D,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,6CAA6C,EAAE,IAAI,CAAC,YAAY,CAAC,uBAAuB,CAAC,CAAC;YACjH,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,yCAAyC,EAAE,YAAY,GAAG,eAAe,IAAI,GAAG,CAAC,CAAC;YACzG,IAAI,CAAC,YAAY,CAAC,IAAI,CAClB,sFAAsF,EACtF,aAAa,GAAG,eAAe,GAAG,IAAI,CAAC,YAAY,CAAC,uBAAuB,IAAI,GAAG,CACrF,CAAC;QACN,CAAC;IACL,CAAC;+GA5YQ,mBAAmB,0EAiGiE,WAAW;mHAjG/F,mBAAmB;;4FAAnB,mBAAmB;kBAD/B,UAAU;;0BAkG+E,MAAM;2BAAC,WAAW","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Inject, Injectable, inject } from '@angular/core';\nimport {\n    AuthConfig,\n    AUTH_CONFIG,\n    OAuthErrorEvent,\n    OAuthEvent,\n    OAuthService,\n    OAuthStorage,\n    TokenResponse,\n    LoginOptions,\n    OAuthSuccessEvent,\n    OAuthLogger\n} from 'angular-oauth2-oidc';\nimport { JwksValidationHandler } from 'angular-oauth2-oidc-jwks';\nimport { from, Observable, race, ReplaySubject } from 'rxjs';\nimport { distinctUntilChanged, filter, map, shareReplay, switchMap, take } from 'rxjs/operators';\nimport { AuthService } from './auth.service';\nimport { AUTH_MODULE_CONFIG, AuthModuleConfig } from './auth-config';\nimport { RetryLoginService } from './retry-login.service';\nimport { TimeSyncService } from '../services/time-sync.service';\n\nconst isPromise = <T>(value: T | Promise<T>): value is Promise<T> => value && typeof (value as Promise<T>).then === 'function';\n\n@Injectable()\nexport class RedirectAuthService extends AuthService {\n    readonly authModuleConfig: AuthModuleConfig = inject(AUTH_MODULE_CONFIG);\n    private readonly _retryLoginService: RetryLoginService = inject(RetryLoginService);\n    private readonly _oauthLogger: OAuthLogger = inject(OAuthLogger);\n    private readonly _timeSyncService: TimeSyncService = inject(TimeSyncService);\n\n    private _isDiscoveryDocumentLoadedSubject$ = new ReplaySubject<boolean>();\n    public isDiscoveryDocumentLoaded$ = this._isDiscoveryDocumentLoadedSubject$.asObservable();\n\n    onLogin: Observable<any>;\n\n    onTokenReceived: Observable<any>;\n\n    private _loadDiscoveryDocumentPromise = Promise.resolve(false);\n\n    /**\n     * Observable stream that emits when the user logs out.\n     *\n     * This observable listens to the events emitted by the OAuth service and filters\n     * them to only include instances of OAuthSuccessEvent with the type `logout`.\n     */\n    onLogout$: Observable<void>;\n\n    /**\n     * Observable stream that emits OAuthErrorEvent instances.\n     *\n     * This observable listens to the events emitted by the OAuth service and filters\n     * them to only include instances of OAuthErrorEvent. It then maps these events\n     * to the correct type.\n     */\n    oauthErrorEvent$: Observable<OAuthErrorEvent>;\n\n    /**\n     * Observable stream that emits the first OAuth error event that occurs.\n     */\n    firstOauthErrorEventOccur$: Observable<OAuthErrorEvent>;\n\n    /**\n     * Observable stream that emits the first OAuth error event that occurs, excluding token refresh errors.\n     */\n    firstOauthErrorEventExcludingTokenRefreshError$: Observable<OAuthErrorEvent>;\n\n    /**\n     * Observable stream that emits the second OAuth token refresh error event that occurs.\n     */\n    secondTokenRefreshErrorEventOccur$: Observable<OAuthErrorEvent>;\n\n    /**\n     * Observable that emits an error when the token has expired due to\n     * the local machine clock being out of sync with the server time.\n     */\n    tokenHasExpiredDueToClockOutOfSync$: Observable<Error>;\n\n    /**\n     * Observable that emits an error when the OAuth error event occurs due to\n     * the local machine clock being out of sync with the server time.\n     */\n    oauthErrorEventOccurDueToClockOutOfSync$: Observable<Error>;\n\n    /**\n     * Observable stream that emits either OAuthErrorEvent or Error.\n     * This stream combines multiple OAuth error sources into a single observable.\n     */\n    combinedOAuthErrorsStream$: Observable<OAuthErrorEvent | Error>;\n\n    /** Subscribe to whether the user has valid Id/Access tokens.  */\n    authenticated$!: Observable<boolean>;\n\n    /** Subscribe to errors reaching the IdP. */\n    idpUnreachable$!: Observable<Error>;\n\n    /**\n     * Get whether the user has valid Id/Access tokens.\n     *\n     * @returns `true` if the user is authenticated, otherwise `false`\n     */\n    get authenticated(): boolean {\n        return this.oauthService.hasValidIdToken() && this.oauthService.hasValidAccessToken();\n    }\n\n    private authConfig!: AuthConfig | Promise<AuthConfig>;\n\n    private readonly AUTH_STORAGE_ITEMS: string[] = [\n        'access_token',\n        'access_token_stored_at',\n        'expires_at',\n        'granted_scopes',\n        'id_token',\n        'id_token_claims_obj',\n        'id_token_expires_at',\n        'id_token_stored_at',\n        'nonce',\n        'PKCE_verifier',\n        'refresh_token',\n        'session_state'\n    ];\n\n    constructor(private oauthService: OAuthService, private _oauthStorage: OAuthStorage, @Inject(AUTH_CONFIG) authConfig: AuthConfig) {\n        super();\n\n        this.authConfig = authConfig;\n\n        this.oauthService.clearHashAfterLogin = true;\n\n        this.oauthService.events.pipe(filter(() => oauthService.showDebugInformation)).subscribe((event) => {\n            if (event instanceof OAuthErrorEvent) {\n                this._oauthLogger.error('OAuthErrorEvent Object:', event);\n            } else {\n                this._oauthLogger.info('OAuthEvent Object:', event);\n            }\n        });\n\n        this.oauthErrorEvent$ = this.oauthService.events.pipe(\n            filter((event) => event instanceof OAuthErrorEvent),\n            map((event) => event as OAuthErrorEvent)\n        );\n\n        this.firstOauthErrorEventOccur$ = this.oauthErrorEvent$.pipe(take(1));\n\n        this.firstOauthErrorEventExcludingTokenRefreshError$ = this.oauthErrorEvent$.pipe(\n            filter((event) => event instanceof OAuthErrorEvent && event.type !== 'token_refresh_error'),\n            take(1)\n        );\n\n        this.secondTokenRefreshErrorEventOccur$ = this.oauthErrorEvent$.pipe(\n            filter((event) => event.type === 'token_refresh_error'),\n            take(2),\n            filter((_, index) => index === 1)\n        );\n\n        this.oauthErrorEventOccurDueToClockOutOfSync$ = this.oauthErrorEvent$.pipe(\n            switchMap(() => this._timeSyncService.checkTimeSync(this.oauthService.clockSkewInSec)),\n            filter((timeSync) => timeSync?.outOfSync),\n            map(\n                (timeSync) =>\n                    new Error(\n                        `OAuth error occurred due to local machine clock ${timeSync.localDateTimeISO} being out of sync with server time ${timeSync.serverDateTimeISO}`\n                    )\n            ),\n            take(1)\n        );\n\n        this.authenticated$ = this.oauthService.events.pipe(\n            map(() => this.authenticated),\n            distinctUntilChanged(),\n            shareReplay(1)\n        );\n\n        this.tokenHasExpiredDueToClockOutOfSync$ = this.oauthService.events.pipe(\n            map(() => !!this.oauthService.getIdentityClaims() && this.tokenHasExpired()),\n            filter((hasExpired) => hasExpired),\n            switchMap(() => this._timeSyncService.checkTimeSync(this.oauthService.clockSkewInSec)),\n            filter((timeSync) => timeSync?.outOfSync),\n            map(\n                (timeSync) =>\n                    new Error(\n                        `Token has expired due to local machine clock ${timeSync.localDateTimeISO} being out of sync with server time ${timeSync.serverDateTimeISO}`\n                    )\n            ),\n            take(1)\n        );\n\n        this.onLogout$ = this.oauthService.events.pipe(\n            filter((event) => event.type === 'logout'),\n            map(() => undefined)\n        );\n\n        this.combinedOAuthErrorsStream$ = race([\n            this.oauthErrorEventOccurDueToClockOutOfSync$,\n            this.firstOauthErrorEventExcludingTokenRefreshError$,\n            this.tokenHasExpiredDueToClockOutOfSync$,\n            this.secondTokenRefreshErrorEventOccur$\n        ]);\n\n        this.combinedOAuthErrorsStream$.subscribe({\n            next: (res) => {\n                this._oauthLogger.error(res);\n                this.logout();\n            },\n            error: () => {}\n        });\n\n        this.oauthService.events.pipe(take(1)).subscribe(() => {\n            if (this.oauthService.getAccessToken() && !this.oauthService.hasValidAccessToken()) {\n                if (this.oauthService.showDebugInformation) {\n                    this._oauthLogger.warn('Access token not valid. Removing all auth items from storage');\n                }\n                this.AUTH_STORAGE_ITEMS.map((item: string) => this._oauthStorage.removeItem(item));\n            }\n        });\n\n        this.onLogin = this.authenticated$.pipe(\n            filter((authenticated) => authenticated),\n            map(() => undefined)\n        );\n\n        this.onTokenReceived = this.oauthService.events.pipe(\n            filter((event: OAuthEvent) => event.type === 'token_received'),\n            map(() => undefined)\n        );\n\n        this.idpUnreachable$ = this.oauthService.events.pipe(\n            filter((event): event is OAuthErrorEvent => event.type === 'discovery_document_load_error'),\n            map((event) => event.reason as Error)\n        );\n    }\n\n    init(): Promise<boolean> {\n        if (isPromise(this.authConfig)) {\n            return this.authConfig.then((config) => this.configureAuth(config));\n        }\n\n        return this.configureAuth(this.authConfig);\n    }\n\n    logout() {\n        this.oauthService.logOut();\n    }\n\n    ensureDiscoveryDocument(): Promise<boolean> {\n        this._loadDiscoveryDocumentPromise = this._loadDiscoveryDocumentPromise\n            .catch(() => false)\n            .then((loaded) => {\n                if (!loaded) {\n                    return this.oauthService.loadDiscoveryDocument().then(() => true);\n                }\n                return true;\n            });\n        return this._loadDiscoveryDocumentPromise;\n    }\n\n    login(currentUrl?: string): void {\n        let stateKey: string | undefined;\n\n        if (currentUrl) {\n            const randomValue = window.crypto.getRandomValues(new Uint32Array(1))[0];\n            stateKey = `auth_state_${randomValue}${Date.now()}`;\n            this._oauthStorage.setItem(stateKey, JSON.stringify(currentUrl || {}));\n        }\n\n        // initLoginFlow will initialize the login flow in either code or implicit depending on the configuration\n        this.ensureDiscoveryDocument().then(() => void this.oauthService.initLoginFlow(stateKey));\n    }\n\n    baseAuthLogin(username: string, password: string): Observable<TokenResponse> {\n        this.oauthService.useHttpBasicAuth = true;\n\n        return from(this.oauthService.fetchTokenUsingPasswordFlow(username, password)).pipe(\n            map((response) => {\n                const props = new Map<string, string>();\n                props.set('id_token', response.id_token);\n                // for backward compatibility we need to set the response in our storage\n                this.oauthService['storeAccessTokenResponse'](\n                    response.access_token,\n                    response.refresh_token,\n                    response.expires_in,\n                    response.scope,\n                    props\n                );\n                return response;\n            })\n        );\n    }\n\n    async loginCallback(loginOptions?: LoginOptions): Promise<string | undefined> {\n        return this.ensureDiscoveryDocument()\n            .then(() =>\n                this._retryLoginService.tryToLoginTimes({\n                    ...loginOptions,\n                    preventClearHashAfterLogin: this.authModuleConfig.preventClearHashAfterLogin\n                })\n            )\n            .then(() => this._getRedirectUrl());\n    }\n\n    private _getRedirectUrl() {\n        const DEFAULT_REDIRECT = '/';\n        const stateKey = this.oauthService.state;\n\n        if (stateKey) {\n            const stateStringified = this._oauthStorage.getItem(stateKey);\n            if (stateStringified) {\n                // cleanup state from storage\n                this._oauthStorage.removeItem(stateKey);\n                return JSON.parse(stateStringified);\n            }\n        }\n\n        return DEFAULT_REDIRECT;\n    }\n\n    private configureAuth(config: AuthConfig): Promise<boolean> {\n        this.oauthService.configure(config);\n        this.oauthService.tokenValidationHandler = new JwksValidationHandler();\n\n        if (config.sessionChecksEnabled) {\n            this.oauthService.events.pipe(filter((event) => event.type === 'session_terminated')).subscribe(() => {\n                this.oauthService.logOut();\n            });\n        }\n\n        return this.ensureDiscoveryDocument()\n            .then(() => {\n                this._isDiscoveryDocumentLoadedSubject$.next(true);\n                this.oauthService.setupAutomaticSilentRefresh();\n                return void this.allowRefreshTokenAndSilentRefreshOnMultipleTabs();\n            })\n            .catch(() => {\n                // catch error to prevent the app from crashing when trying to access unprotected routes\n            });\n    }\n\n    /**\n     * Fix a known issue (https://github.com/manfredsteyer/angular-oauth2-oidc/issues/850)\n     * where multiple tabs can cause the token refresh and the silent refresh to fail.\n     * This patch is based on the solutions provided in the following comments:\n     * https://github.com/manfredsteyer/angular-oauth2-oidc/issues/850#issuecomment-889921776 fix silent refresh for the implicit flow\n     * https://github.com/manfredsteyer/angular-oauth2-oidc/issues/850#issuecomment-1557286966 fix refresh token for the code flow\n     */\n    private allowRefreshTokenAndSilentRefreshOnMultipleTabs() {\n        let lastUpdatedAccessToken: string | undefined;\n\n        if (this.oauthService.hasValidAccessToken()) {\n            lastUpdatedAccessToken = this.oauthService.getAccessToken();\n        }\n\n        const originalRefreshToken = this.oauthService.refreshToken.bind(this.oauthService);\n        this.oauthService.refreshToken = (): Promise<TokenResponse> =>\n            navigator.locks.request(`refresh_tokens_${location.origin}`, () => {\n                if (!!lastUpdatedAccessToken && lastUpdatedAccessToken !== this.oauthService.getAccessToken()) {\n                    (this.oauthService as any).eventsSubject.next(new OAuthSuccessEvent('token_received'));\n                    (this.oauthService as any).eventsSubject.next(new OAuthSuccessEvent('token_refreshed'));\n                    lastUpdatedAccessToken = this.oauthService.getAccessToken();\n                    return;\n                }\n\n                return originalRefreshToken().then((resp) => (lastUpdatedAccessToken = resp.access_token));\n            });\n\n        const originalSilentRefresh = this.oauthService.silentRefresh.bind(this.oauthService);\n        this.oauthService.silentRefresh = async (params: any = {}, noPrompt = true): Promise<OAuthEvent> =>\n            navigator.locks.request(`silent_refresh_${location.origin}`, async (): Promise<OAuthEvent> => {\n                if (lastUpdatedAccessToken !== this.oauthService.getAccessToken()) {\n                    (this.oauthService as any).eventsSubject.next(new OAuthSuccessEvent('token_received'));\n                    (this.oauthService as any).eventsSubject.next(new OAuthSuccessEvent('token_refreshed'));\n                    const event = new OAuthSuccessEvent('silently_refreshed');\n                    (this.oauthService as any).eventsSubject.next(event);\n                    lastUpdatedAccessToken = this.oauthService.getAccessToken();\n                    return event;\n                } else {\n                    return originalSilentRefresh(params, noPrompt);\n                }\n            });\n    }\n\n    updateIDPConfiguration(config: AuthConfig) {\n        this.oauthService.configure(config);\n    }\n\n    /**\n     * Checks if the token has expired.\n     *\n     * This method retrieves the identity claims from the OAuth service and calculates\n     * the token's issued and expiration times. It then compares the current time with\n     * these values, considering a clock skew and a configurable expiration decrease.\n     *\n     * @returns - Returns `true` if the token has expired, otherwise `false`.\n     */\n    tokenHasExpired() {\n        const claims = this.oauthService.getIdentityClaims();\n        if (!claims) {\n            this._oauthLogger.warn('No claims found in the token');\n            return false;\n        }\n        const now = Date.now();\n        const issuedAtMSec = claims.iat * 1000;\n        const expiresAtMSec = claims.exp * 1000;\n        const clockSkewInMSec = this.oauthService.clockSkewInSec * 1000;\n\n        this.showTokenExpiredDebugInformations(now, issuedAtMSec, expiresAtMSec, clockSkewInMSec);\n        return issuedAtMSec - clockSkewInMSec >= now || expiresAtMSec + clockSkewInMSec - this.oauthService.decreaseExpirationBySec <= now;\n    }\n\n    private showTokenExpiredDebugInformations(now: number, issuedAtMSec: number, expiresAtMSec: number, clockSkewInMSec: number) {\n        if (this.oauthService.showDebugInformation) {\n            this._oauthLogger.warn('now: ', new Date(now));\n            this._oauthLogger.warn('issuedAt: ', new Date(issuedAtMSec));\n            this._oauthLogger.warn('expiresAt: ', new Date(expiresAtMSec));\n            this._oauthLogger.warn('clockSkewInMSec: ', clockSkewInMSec);\n            this._oauthLogger.warn('this.oauthService.decreaseExpirationBySec: ', this.oauthService.decreaseExpirationBySec);\n            this._oauthLogger.warn('issuedAtMSec - clockSkewInMSec >= now: ', issuedAtMSec - clockSkewInMSec >= now);\n            this._oauthLogger.warn(\n                'expiresAtMSec + clockSkewInMSec - this.oauthService.decreaseExpirationBySec <= now: ',\n                expiresAtMSec + clockSkewInMSec - this.oauthService.decreaseExpirationBySec <= now\n            );\n        }\n    }\n}\n"]}

package/esm2022/lib/auth/oidc/retry-login.service.mjs

@@ -0,0 +1,66 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { inject, Injectable } from '@angular/core';
+import { OAuthErrorEvent, OAuthService } from 'angular-oauth2-oidc';
+import * as i0 from "@angular/core";
+export class RetryLoginService {
+    constructor() {
+        this.oauthService = inject(OAuthService);
+    }
+    /**
+     * Attempts to log in a specified number of times if the initial login attempt fails.
+     *
+     * @param loginOptions - The options to be used for the login attempt.
+     * @param maxLoginAttempts - The maximum number of login attempts. Defaults to 3.
+     * @returns A promise that resolves to `true` if the login is successful, or rejects with an error if all attempts fail.
+     */
+    tryToLoginTimes(loginOptions, maxLoginAttempts = 3) {
+        let retryCount = 0;
+        const maxRetries = maxLoginAttempts - 1;
+        const attemptLogin = () => this.oauthService.tryLogin({ ...loginOptions }).catch((error) => {
+            if (retryCount < maxRetries) {
+                console.error(`Login attempt ${retryCount + 1} of ${maxLoginAttempts} failed. ${retryCount < maxLoginAttempts - 1 ? 'Retrying...' : ''}`);
+                retryCount++;
+                return attemptLogin();
+            }
+            else {
+                const errorMessage = this.getErrorMessage(error, maxLoginAttempts);
+                throw new Error(errorMessage);
+            }
+        });
+        return attemptLogin();
+    }
+    getErrorMessage(error, maxLoginAttempts) {
+        const isOAuthErrorEvent = error instanceof OAuthErrorEvent;
+        let oAuthErrorMessage;
+        if (isOAuthErrorEvent) {
+            oAuthErrorMessage = error.reason?.reason || error.type.toString();
+        }
+        const errorDescription = oAuthErrorMessage || error;
+        const errorMessage = `Login failed after ${maxLoginAttempts} attempts. caused by: ${errorDescription}`;
+        return errorMessage;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RetryLoginService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RetryLoginService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RetryLoginService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth/oidc/token.interceptor.mjs

@@ -0,0 +1,62 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { inject, Injectable } from '@angular/core';
+import { HttpResponse } from '@angular/common/http';
+import { tap } from 'rxjs/operators';
+import { OAuthService, OAuthStorage } from 'angular-oauth2-oidc';
+import * as i0 from "@angular/core";
+/**
+ * TokenInterceptor is an HTTP interceptor that processes HTTP requests and responses
+ * to handle the id_token. It checks if the request URL matches the token endpoint
+ * and processes the response to store the `id_token` in the OAuth storage if it is
+ * not already set.
+ * The purpose of this interceptor is to fix the missing `id_token_hint` required by the Idp to complete the logout.
+ * `id_token_hint` is set by the `angular-oauth2-oidc` library only when the `id_token` is set in the storage.
+ * https://github.com/manfredsteyer/angular-oauth2-oidc/blob/15.0.0/projects/lib/src/oauth-service.ts#L2555
+ *
+ * See the related issue: https://github.com/manfredsteyer/angular-oauth2-oidc/issues/1443
+ *
+ * @function intercept
+ * @param {HttpRequest<unknown>} request - The outgoing HTTP request.
+ * @param {HttpHandler} next - The next handler in the HTTP request chain.
+ * @returns {Observable<HttpEvent<unknown>>} An observable of the HTTP event.
+ */
+export class TokenInterceptor {
+    constructor() {
+        this._oauthStorage = inject(OAuthStorage);
+        this._oauthService = inject(OAuthService);
+    }
+    intercept(request, next) {
+        const tokenEndpoint = this._oauthService.tokenEndpoint;
+        if (tokenEndpoint && request.url === tokenEndpoint) {
+            return next.handle(request).pipe(tap((event) => {
+                if (event instanceof HttpResponse) {
+                    if (!this._oauthService.getIdToken() && event?.body?.id_token) {
+                        this._oauthStorage.setItem('id_token', event.body.id_token);
+                    }
+                }
+            }));
+        }
+        return next.handle(request);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TokenInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TokenInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TokenInterceptor, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth/oidc/view/authentication-confirmation/authentication-confirmation.component.mjs

@@ -0,0 +1,31 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AuthenticationConfirmationComponent {
+    constructor() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthenticationConfirmationComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: AuthenticationConfirmationComponent, selector: "ng-component", ngImport: i0, template: '<div data-automation-id="auth-confirmation"></div>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthenticationConfirmationComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: '<div data-automation-id="auth-confirmation"></div>',
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth/public-api.mjs

@@ -0,0 +1,44 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './authentication-interceptor/auth-bearer.interceptor';
+export * from './guard/auth-guard.service';
+export * from './guard/auth-guard';
+export * from './guard/auth-guard-ecm.service';
+export * from './guard/auth-guard-bpm.service';
+export * from './guard/auth-guard-sso-role.service';
+export * from './services/authentication.service';
+export * from './services/identity-role.service';
+export * from './services/identity-user.service';
+export * from './services/identity-group.service';
+export * from './services/jwt-helper.service';
+export * from './services/oauth2.service';
+export * from './services/user-access.service';
+export * from './basic-auth/basic-alfresco-auth.service';
+export * from './basic-auth/process-auth';
+export * from './basic-auth/content-auth';
+export * from './interfaces/identity-user.service.interface';
+export * from './interfaces/identity-group.interface';
+export * from './interfaces/openid-configuration.interface';
+export * from './models/oauth-config.model';
+export * from './models/redirection.model';
+export * from './models/identity-group.model';
+export * from './models/identity-user.model';
+export * from './models/identity-role.model';
+export * from './models/user-access.model';
+export * from './models/application-access.model';
+export * from './oidc/public-api';
+//# sourceMappingURL=data:application/json;base64,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