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

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

@@ -0,0 +1,110 @@
+/*!
+ * @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 { AuthConfig } from 'angular-oauth2-oidc';
+import { take } from 'rxjs/operators';
+import { AppConfigService } from '../../app-config/app-config.service';
+import { AUTH_MODULE_CONFIG } from './auth-config';
+import * as i0 from "@angular/core";
+import * as i1 from "../../app-config/app-config.service";
+/**
+ * Create auth configuration factory
+ *
+ * @param authConfigService auth config service
+ * @returns factory function
+ */
+export function authConfigFactory(authConfigService) {
+    return authConfigService.loadConfig();
+}
+export class AuthConfigService {
+    constructor(appConfigService, authModuleConfig) {
+        this.appConfigService = appConfigService;
+        this.authModuleConfig = authModuleConfig;
+    }
+    get authConfig() {
+        return this._authConfig;
+    }
+    loadConfig() {
+        return this.appConfigService.onLoad.pipe(take(1)).toPromise().then(this.loadAppConfig.bind(this));
+    }
+    loadAppConfig() {
+        const oauth2 = this.appConfigService.oauth2;
+        const origin = this.getLocationOrigin();
+        const redirectUri = this.getRedirectUri();
+        const customQueryParams = oauth2.audience ? { audience: oauth2.audience } : {};
+        const clockSkewInSec = this.getClockSkewInSec(oauth2);
+        const sessionChecksEnabled = this.getSessionCheckEnabled(oauth2);
+        return new AuthConfig({
+            ...oauth2,
+            oidc: oauth2.implicitFlow || oauth2.codeFlow || false,
+            issuer: oauth2.host,
+            nonceStateSeparator: '~',
+            redirectUri,
+            silentRefreshRedirectUri: oauth2.redirectSilentIframeUri,
+            postLogoutRedirectUri: this.generatePostLogoutUri(origin, oauth2.redirectUriLogout),
+            clientId: oauth2.clientId,
+            scope: oauth2.scope,
+            dummyClientSecret: oauth2.secret || '',
+            logoutUrl: oauth2.logoutUrl,
+            customQueryParams,
+            ...(oauth2.codeFlow && { responseType: 'code' }),
+            ...clockSkewInSec,
+            ...sessionChecksEnabled
+        });
+    }
+    getSessionCheckEnabled(oauth2) {
+        return typeof oauth2.sessionChecksEnabled === 'boolean' ? { sessionChecksEnabled: oauth2.sessionChecksEnabled } : {};
+    }
+    getClockSkewInSec(oauth2) {
+        return typeof oauth2.clockSkewInSec === 'number' ? { clockSkewInSec: oauth2.clockSkewInSec } : {};
+    }
+    getRedirectUri() {
+        // required for this package as we handle the returned token on this view, with is provided by the AuthModule
+        const viewUrl = `view/authentication-confirmation`;
+        const useHash = this.authModuleConfig.useHash;
+        const oauth2 = this.appConfigService.oauth2;
+        const directUrl = oauth2.redirectUri?.startsWith('http');
+        if (directUrl) {
+            return oauth2.redirectUri;
+        }
+        const locationOrigin = oauth2.redirectUri && oauth2.redirectUri !== '/' ? this.getLocationOrigin() + '' + oauth2.redirectUri : this.getLocationOrigin();
+        const redirectUri = useHash ? `${locationOrigin}/#/${viewUrl}` : `${locationOrigin}/${viewUrl}`;
+        // handle issue from the OIDC library with hashStrategy and implicitFlow, with would append &state to the url with would lead to error
+        // `cannot match any routes`, and displaying the wildcard ** error page
+        return (oauth2.codeFlow || oauth2.implicitFlow) && useHash ? `${redirectUri}/?` : redirectUri;
+    }
+    getLocationOrigin() {
+        return window.location.origin;
+    }
+    generatePostLogoutUri(hostUri = '', redirectUriLogout = '') {
+        const hostUriWithoutSlash = hostUri.endsWith('/') ? hostUri.substring(0, hostUri.length - 1) : hostUri;
+        const redirectUriLogoutWithoutSlash = redirectUriLogout.startsWith('/') ? redirectUriLogout.substring(1) : redirectUriLogout;
+        return `${hostUriWithoutSlash}/${redirectUriLogoutWithoutSlash}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthConfigService, deps: [{ token: i1.AppConfigService }, { token: AUTH_MODULE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AppConfigService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [AUTH_MODULE_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-config.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/auth/oidc/auth-config.service.ts"],"names":[],"mappings":"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","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 } from '@angular/core';\nimport { AuthConfig } from 'angular-oauth2-oidc';\nimport { take } from 'rxjs/operators';\nimport { AppConfigService } from '../../app-config/app-config.service';\nimport { AUTH_MODULE_CONFIG, AuthModuleConfig } from './auth-config';\nimport { OauthConfigModel } from '../models/oauth-config.model';\n\n/**\n * Create auth configuration factory\n *\n * @param authConfigService auth config service\n * @returns factory function\n */\nexport function authConfigFactory(authConfigService: AuthConfigService): Promise<AuthConfig> {\n    return authConfigService.loadConfig();\n}\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class AuthConfigService {\n    constructor(private appConfigService: AppConfigService, @Inject(AUTH_MODULE_CONFIG) private readonly authModuleConfig: AuthModuleConfig) {}\n\n    private _authConfig!: AuthConfig;\n    get authConfig(): AuthConfig {\n        return this._authConfig;\n    }\n\n    loadConfig(): Promise<AuthConfig> {\n        return this.appConfigService.onLoad.pipe(take(1)).toPromise().then(this.loadAppConfig.bind(this));\n    }\n\n    loadAppConfig(): AuthConfig {\n        const oauth2 = this.appConfigService.oauth2;\n        const origin = this.getLocationOrigin();\n        const redirectUri = this.getRedirectUri();\n        const customQueryParams = oauth2.audience ? { audience: oauth2.audience } : {};\n        const clockSkewInSec = this.getClockSkewInSec(oauth2);\n        const sessionChecksEnabled = this.getSessionCheckEnabled(oauth2);\n\n        return new AuthConfig({\n            ...oauth2,\n            oidc: oauth2.implicitFlow || oauth2.codeFlow || false,\n            issuer: oauth2.host,\n            nonceStateSeparator: '~',\n            redirectUri,\n            silentRefreshRedirectUri: oauth2.redirectSilentIframeUri,\n            postLogoutRedirectUri: this.generatePostLogoutUri(origin, oauth2.redirectUriLogout),\n            clientId: oauth2.clientId,\n            scope: oauth2.scope,\n            dummyClientSecret: oauth2.secret || '',\n            logoutUrl: oauth2.logoutUrl,\n            customQueryParams,\n            ...(oauth2.codeFlow && { responseType: 'code' }),\n            ...clockSkewInSec,\n            ...sessionChecksEnabled\n        });\n    }\n\n    getSessionCheckEnabled(oauth2: OauthConfigModel) {\n        return typeof oauth2.sessionChecksEnabled === 'boolean' ? { sessionChecksEnabled: oauth2.sessionChecksEnabled } : {};\n    }\n\n    getClockSkewInSec(oauth2: OauthConfigModel) {\n        return typeof oauth2.clockSkewInSec === 'number' ? { clockSkewInSec: oauth2.clockSkewInSec } : {};\n    }\n\n    getRedirectUri(): string {\n        // required for this package as we handle the returned token on this view, with is provided by the AuthModule\n        const viewUrl = `view/authentication-confirmation`;\n        const useHash = this.authModuleConfig.useHash;\n\n        const oauth2 = this.appConfigService.oauth2;\n\n        const directUrl = oauth2.redirectUri?.startsWith('http');\n        if (directUrl) {\n            return oauth2.redirectUri;\n        }\n\n        const locationOrigin =\n            oauth2.redirectUri && oauth2.redirectUri !== '/' ? this.getLocationOrigin() + '' + oauth2.redirectUri : this.getLocationOrigin();\n\n        const redirectUri = useHash ? `${locationOrigin}/#/${viewUrl}` : `${locationOrigin}/${viewUrl}`;\n\n        // handle issue from the OIDC library with hashStrategy and implicitFlow, with would append &state to the url with would lead to error\n        // `cannot match any routes`, and displaying the wildcard ** error page\n        return (oauth2.codeFlow || oauth2.implicitFlow) && useHash ? `${redirectUri}/?` : redirectUri;\n    }\n\n    private getLocationOrigin() {\n        return window.location.origin;\n    }\n\n    private generatePostLogoutUri(hostUri: string = '', redirectUriLogout: string = ''): string {\n        const hostUriWithoutSlash = hostUri.endsWith('/') ? hostUri.substring(0, hostUri.length - 1) : hostUri;\n        const redirectUriLogoutWithoutSlash = redirectUriLogout.startsWith('/') ? redirectUriLogout.substring(1) : redirectUriLogout;\n\n        return `${hostUriWithoutSlash}/${redirectUriLogoutWithoutSlash}`;\n    }\n}\n"]}

package/esm2022/lib/auth/oidc/auth-routing.module.mjs

@@ -0,0 +1,34 @@
+/*!
+ * @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 { NgModule } from '@angular/core';
+import { provideRouter } from '@angular/router';
+import { AuthenticationConfirmationComponent } from './view/authentication-confirmation/authentication-confirmation.component';
+import { OidcAuthGuard } from './oidc-auth.guard';
+import * as i0 from "@angular/core";
+const routes = [{ path: 'view/authentication-confirmation', component: AuthenticationConfirmationComponent, canActivate: [OidcAuthGuard] }];
+export class AuthRoutingModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthRoutingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: AuthRoutingModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthRoutingModule, providers: [provideRouter(routes)] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthRoutingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [provideRouter(routes)]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth/oidc/auth.module.mjs

@@ -0,0 +1,112 @@
+/*!
+ * @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 { APP_INITIALIZER, inject, NgModule, InjectionToken } from '@angular/core';
+import { AUTH_CONFIG, OAuthModule, OAuthStorage } from 'angular-oauth2-oidc';
+import { AuthenticationService } from '../services/authentication.service';
+import { AUTH_MODULE_CONFIG } from './auth-config';
+import { authConfigFactory, AuthConfigService } from './auth-config.service';
+import { AuthRoutingModule } from './auth-routing.module';
+import { AuthService } from './auth.service';
+import { RedirectAuthService } from './redirect-auth.service';
+import { AuthenticationConfirmationComponent } from './view/authentication-confirmation/authentication-confirmation.component';
+import { HTTP_INTERCEPTORS } from '@angular/common/http';
+import { TokenInterceptor } from './token.interceptor';
+import { StorageService } from '../../common/services/storage.service';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-oauth2-oidc";
+export const JWT_STORAGE_SERVICE = new InjectionToken('JWT_STORAGE_SERVICE', {
+    providedIn: 'root',
+    factory: () => inject(StorageService)
+});
+/**
+ * Create a Login Factory function
+ *
+ * @param redirectService auth redirect service
+ * @returns a factory function
+ */
+export function loginFactory(redirectService) {
+    return () => redirectService.init();
+}
+/**
+ *  @returns current instance of OAuthStorage
+ */
+export function oauthStorageFactory() {
+    return inject(JWT_STORAGE_SERVICE);
+}
+export class AuthModule {
+    static forRoot(config = { useHash: false }) {
+        config.preventClearHashAfterLogin = config.preventClearHashAfterLogin ?? true;
+        return {
+            ngModule: AuthModule,
+            providers: [{ provide: AUTH_MODULE_CONFIG, useValue: config }]
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: AuthModule, declarations: [AuthenticationConfirmationComponent], imports: [AuthRoutingModule, i1.OAuthModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthModule, providers: [
+            { provide: OAuthStorage, useFactory: oauthStorageFactory },
+            { provide: AuthenticationService },
+            {
+                provide: AUTH_CONFIG,
+                useFactory: authConfigFactory,
+                deps: [AuthConfigService]
+            },
+            RedirectAuthService,
+            { provide: AuthService, useExisting: RedirectAuthService },
+            {
+                provide: APP_INITIALIZER,
+                useFactory: loginFactory,
+                deps: [RedirectAuthService],
+                multi: true
+            },
+            {
+                provide: HTTP_INTERCEPTORS,
+                useClass: TokenInterceptor,
+                multi: true
+            }
+        ], imports: [AuthRoutingModule, OAuthModule.forRoot()] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AuthenticationConfirmationComponent],
+                    imports: [AuthRoutingModule, OAuthModule.forRoot()],
+                    providers: [
+                        { provide: OAuthStorage, useFactory: oauthStorageFactory },
+                        { provide: AuthenticationService },
+                        {
+                            provide: AUTH_CONFIG,
+                            useFactory: authConfigFactory,
+                            deps: [AuthConfigService]
+                        },
+                        RedirectAuthService,
+                        { provide: AuthService, useExisting: RedirectAuthService },
+                        {
+                            provide: APP_INITIALIZER,
+                            useFactory: loginFactory,
+                            deps: [RedirectAuthService],
+                            multi: true
+                        },
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: TokenInterceptor,
+                            multi: true
+                        }
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,22 @@
+/*!
+ * @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.
+ */
+/**
+ * Provide authentication/authorization through OAuth2/OIDC protocol.
+ */
+export class AuthService {
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth/oidc/oidc-auth.guard.mjs

@@ -0,0 +1,37 @@
+/*!
+ * @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 } from '@angular/core';
+import { Router } from '@angular/router';
+import { AuthService } from './auth.service';
+const ROUTE_DEFAULT = '/';
+export const OidcAuthGuard = async () => {
+    let onLogoutEmitted = false;
+    const authService = inject(AuthService);
+    const router = inject(Router);
+    authService.onLogout$.subscribe(() => (onLogoutEmitted = true));
+    try {
+        const route = await authService.loginCallback({ customHashFragment: window.location.search });
+        return router.navigateByUrl(route, { replaceUrl: true });
+    }
+    catch (error) {
+        if (onLogoutEmitted) {
+            throw error;
+        }
+        return router.navigateByUrl(ROUTE_DEFAULT, { replaceUrl: true });
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,202 @@
+/*!
+ * @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 { Injectable } from '@angular/core';
+import { OAuthService, OAuthStorage } from 'angular-oauth2-oidc';
+import { defer, EMPTY, combineLatest } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { AppConfigService, AppConfigValues } from '../../app-config/app-config.service';
+import { BaseAuthenticationService } from '../services/base-authentication.service';
+import { CookieService } from '../../common/services/cookie.service';
+import { JwtHelperService } from '../services/jwt-helper.service';
+import { AuthConfigService } from './auth-config.service';
+import { AuthService } from './auth.service';
+import { Minimatch } from 'minimatch';
+import * as i0 from "@angular/core";
+import * as i1 from "../../app-config/app-config.service";
+import * as i2 from "../../common/services/cookie.service";
+import * as i3 from "../services/jwt-helper.service";
+import * as i4 from "angular-oauth2-oidc";
+import * as i5 from "./auth-config.service";
+import * as i6 from "./auth.service";
+export class OidcAuthenticationService extends BaseAuthenticationService {
+    constructor(appConfig, cookie, jwtHelperService, authStorage, oauthService, authConfig, auth) {
+        super(appConfig, cookie);
+        this.jwtHelperService = jwtHelperService;
+        this.authStorage = authStorage;
+        this.oauthService = oauthService;
+        this.authConfig = authConfig;
+        this.auth = auth;
+        /**
+         * Observable that determines whether an SSO login should be performed.
+         *
+         * This observable combines the authentication status and the discovery document load status
+         * to decide if an SSO login is necessary. It emits `true` if the user is not authenticated
+         * and the discovery document is loaded, otherwise it emits `false`.
+         */
+        this.shouldPerformSsoLogin$ = combineLatest([this.auth.authenticated$, this.auth.isDiscoveryDocumentLoaded$]).pipe(map(([authenticated, isDiscoveryDocumentLoaded]) => !authenticated && isDiscoveryDocumentLoaded));
+    }
+    isEcmLoggedIn() {
+        if (this.isECMProvider() || this.isALLProvider()) {
+            return this.isLoggedIn();
+        }
+        return false;
+    }
+    isBpmLoggedIn() {
+        if (this.isBPMProvider() || this.isALLProvider()) {
+            return this.isLoggedIn();
+        }
+        return false;
+    }
+    isLoggedIn() {
+        return this.oauthService.hasValidAccessToken() && this.oauthService.hasValidIdToken();
+    }
+    hasValidAccessToken() {
+        return this.oauthService.hasValidAccessToken();
+    }
+    hasValidIdToken() {
+        return this.oauthService.hasValidIdToken();
+    }
+    isImplicitFlow() {
+        const oauth2 = Object.assign({}, this.appConfig.get(AppConfigValues.OAUTHCONFIG, null));
+        return !!oauth2?.implicitFlow;
+    }
+    isAuthCodeFlow() {
+        const oauth2 = Object.assign({}, this.appConfig.get(AppConfigValues.OAUTHCONFIG, null));
+        return !!oauth2?.codeFlow;
+    }
+    login(username, password) {
+        return this.auth.baseAuthLogin(username, password).pipe(map((response) => {
+            this.onLogin.next(response);
+            return {
+                type: this.appConfig.get(AppConfigValues.PROVIDERS),
+                ticket: response
+            };
+        }), catchError((err) => this.handleError(err)));
+    }
+    loginWithPassword(username, password) {
+        return defer(async () => {
+            try {
+                await this.authConfig.loadConfig();
+                await this.oauthService.loadDiscoveryDocument();
+                await this.oauthService.fetchTokenUsingPasswordFlowAndLoadUserProfile(username, password);
+                await this.oauthService.refreshToken();
+                const accessToken = this.oauthService.getAccessToken();
+                this.onLogin.next(accessToken);
+                return {
+                    type: this.appConfig.get(AppConfigValues.PROVIDERS),
+                    ticket: accessToken
+                };
+            }
+            catch (err) {
+                throw this.handleError(err);
+            }
+        });
+    }
+    getUsername() {
+        return this.jwtHelperService.getValueFromLocalToken(JwtHelperService.USER_PREFERRED_USERNAME);
+    }
+    /**
+     * @deprecated
+     * @returns the logged username
+     */
+    getEcmUsername() {
+        return this.getUsername();
+    }
+    /**
+     * @deprecated
+     * @returns the logged username
+     */
+    getBpmUsername() {
+        return this.getUsername();
+    }
+    ssoLogin(redirectUrl) {
+        this.auth.login(redirectUrl);
+    }
+    ssoCodeFlowLogin() {
+        this.oauthService.initCodeFlow();
+    }
+    isRememberMeSet() {
+        return true;
+    }
+    logout() {
+        const logoutOptions = this.getLogoutOptions();
+        this.oauthService.logOut(logoutOptions);
+        return EMPTY;
+    }
+    getToken() {
+        return this.authStorage.getItem(JwtHelperService.USER_ACCESS_TOKEN);
+    }
+    reset() {
+        const config = this.authConfig.loadAppConfig();
+        this.auth.updateIDPConfiguration(config);
+    }
+    isPublicUrl() {
+        const oauth2 = this.appConfig.get(AppConfigValues.OAUTHCONFIG, null);
+        if (Array.isArray(oauth2.publicUrls)) {
+            return (oauth2.publicUrls.length > 0 &&
+                oauth2.publicUrls.some((urlPattern) => {
+                    const minimatch = new Minimatch(urlPattern);
+                    return minimatch.match(window.location.href);
+                }));
+        }
+        return false;
+    }
+    getAuthHeaders(_requestUrl, header) {
+        return this.addBearerToken(header);
+    }
+    addBearerToken(header) {
+        const token = this.getToken();
+        if (!token) {
+            return header;
+        }
+        return header.set('Authorization', 'bearer ' + token);
+    }
+    getLogoutOptions() {
+        const oauth2Config = this.appConfig.get(AppConfigValues.OAUTHCONFIG, null);
+        const logoutParamsList = oauth2Config?.logoutParameters || [];
+        return logoutParamsList.reduce((options, param) => {
+            const value = this.getLogoutParamValue(param);
+            if (value !== undefined) {
+                options[param] = value;
+            }
+            return options;
+        }, {});
+    }
+    getLogoutParamValue(param) {
+        switch (param) {
+            case 'client_id':
+                return this.oauthService.clientId;
+            case 'returnTo':
+                return this.oauthService.redirectUri;
+            case 'redirect_uri':
+                return this.oauthService.redirectUri;
+            case 'response_type':
+                return 'code';
+            default:
+                return undefined;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OidcAuthenticationService, deps: [{ token: i1.AppConfigService }, { token: i2.CookieService }, { token: i3.JwtHelperService }, { token: i4.OAuthStorage }, { token: i4.OAuthService }, { token: i5.AuthConfigService }, { token: i6.AuthService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OidcAuthenticationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OidcAuthenticationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AppConfigService }, { type: i2.CookieService }, { type: i3.JwtHelperService }, { type: i4.OAuthStorage }, { type: i4.OAuthService }, { type: i5.AuthConfigService }, { type: i6.AuthService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"oidc-authentication.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/auth/oidc/oidc-authentication.service.ts"],"names":[],"mappings":"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","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 { Injectable } from '@angular/core';\nimport { OAuthService, OAuthStorage } from 'angular-oauth2-oidc';\nimport { Observable, defer, EMPTY, combineLatest } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\nimport { AppConfigService, AppConfigValues } from '../../app-config/app-config.service';\nimport { OauthConfigModel } from '../models/oauth-config.model';\nimport { BaseAuthenticationService } from '../services/base-authentication.service';\nimport { CookieService } from '../../common/services/cookie.service';\nimport { JwtHelperService } from '../services/jwt-helper.service';\nimport { AuthConfigService } from './auth-config.service';\nimport { AuthService } from './auth.service';\nimport { Minimatch } from 'minimatch';\nimport { HttpHeaders } from '@angular/common/http';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class OidcAuthenticationService extends BaseAuthenticationService {\n    constructor(\n        appConfig: AppConfigService,\n        cookie: CookieService,\n        private jwtHelperService: JwtHelperService,\n        private authStorage: OAuthStorage,\n        private oauthService: OAuthService,\n        private readonly authConfig: AuthConfigService,\n        private readonly auth: AuthService\n    ) {\n        super(appConfig, cookie);\n    }\n\n    /**\n     * Observable that determines whether an SSO login should be performed.\n     *\n     * This observable combines the authentication status and the discovery document load status\n     * to decide if an SSO login is necessary. It emits `true` if the user is not authenticated\n     * and the discovery document is loaded, otherwise it emits `false`.\n     */\n    shouldPerformSsoLogin$: Observable<boolean> = combineLatest([this.auth.authenticated$, this.auth.isDiscoveryDocumentLoaded$]).pipe(\n        map(([authenticated, isDiscoveryDocumentLoaded]) => !authenticated && isDiscoveryDocumentLoaded)\n    );\n\n    isEcmLoggedIn(): boolean {\n        if (this.isECMProvider() || this.isALLProvider()) {\n            return this.isLoggedIn();\n        }\n        return false;\n    }\n\n    isBpmLoggedIn(): boolean {\n        if (this.isBPMProvider() || this.isALLProvider()) {\n            return this.isLoggedIn();\n        }\n        return false;\n    }\n\n    isLoggedIn(): boolean {\n        return this.oauthService.hasValidAccessToken() && this.oauthService.hasValidIdToken();\n    }\n\n    hasValidAccessToken(): boolean {\n        return this.oauthService.hasValidAccessToken();\n    }\n\n    hasValidIdToken(): boolean {\n        return this.oauthService.hasValidIdToken();\n    }\n\n    isImplicitFlow() {\n        const oauth2: OauthConfigModel = Object.assign({}, this.appConfig.get<OauthConfigModel>(AppConfigValues.OAUTHCONFIG, null));\n        return !!oauth2?.implicitFlow;\n    }\n\n    isAuthCodeFlow() {\n        const oauth2: OauthConfigModel = Object.assign({}, this.appConfig.get<OauthConfigModel>(AppConfigValues.OAUTHCONFIG, null));\n        return !!oauth2?.codeFlow;\n    }\n\n    login(username: string, password: string): Observable<{ type: string; ticket: any }> {\n        return this.auth.baseAuthLogin(username, password).pipe(\n            map((response) => {\n                this.onLogin.next(response);\n                return {\n                    type: this.appConfig.get(AppConfigValues.PROVIDERS),\n                    ticket: response\n                };\n            }),\n            catchError((err) => this.handleError(err))\n        );\n    }\n\n    loginWithPassword(username: string, password: string): Observable<{ type: string; ticket: any }> {\n        return defer(async () => {\n            try {\n                await this.authConfig.loadConfig();\n                await this.oauthService.loadDiscoveryDocument();\n                await this.oauthService.fetchTokenUsingPasswordFlowAndLoadUserProfile(username, password);\n                await this.oauthService.refreshToken();\n                const accessToken = this.oauthService.getAccessToken();\n                this.onLogin.next(accessToken);\n\n                return {\n                    type: this.appConfig.get(AppConfigValues.PROVIDERS) as string,\n                    ticket: accessToken\n                };\n            } catch (err) {\n                throw this.handleError(err);\n            }\n        });\n    }\n\n    getUsername() {\n        return this.jwtHelperService.getValueFromLocalToken<string>(JwtHelperService.USER_PREFERRED_USERNAME);\n    }\n\n    /**\n     * @deprecated\n     * @returns the logged username\n     */\n    getEcmUsername(): string {\n        return this.getUsername();\n    }\n\n    /**\n     * @deprecated\n     * @returns the logged username\n     */\n    getBpmUsername(): string {\n        return this.getUsername();\n    }\n\n    ssoLogin(redirectUrl?: string) {\n        this.auth.login(redirectUrl);\n    }\n\n    ssoCodeFlowLogin() {\n        this.oauthService.initCodeFlow();\n    }\n\n    isRememberMeSet(): boolean {\n        return true;\n    }\n\n    logout() {\n        const logoutOptions = this.getLogoutOptions();\n        this.oauthService.logOut(logoutOptions);\n        return EMPTY;\n    }\n\n    getToken(): string {\n        return this.authStorage.getItem(JwtHelperService.USER_ACCESS_TOKEN);\n    }\n\n    reset(): void {\n        const config = this.authConfig.loadAppConfig();\n        this.auth.updateIDPConfiguration(config);\n    }\n\n    isPublicUrl(): boolean {\n        const oauth2 = this.appConfig.get<OauthConfigModel>(AppConfigValues.OAUTHCONFIG, null);\n\n        if (Array.isArray(oauth2.publicUrls)) {\n            return (\n                oauth2.publicUrls.length > 0 &&\n                oauth2.publicUrls.some((urlPattern: string) => {\n                    const minimatch = new Minimatch(urlPattern);\n                    return minimatch.match(window.location.href);\n                })\n            );\n        }\n        return false;\n    }\n\n    getAuthHeaders(_requestUrl: string, header: HttpHeaders): HttpHeaders {\n        return this.addBearerToken(header);\n    }\n\n    private addBearerToken(header: HttpHeaders): HttpHeaders {\n        const token: string = this.getToken();\n\n        if (!token) {\n            return header;\n        }\n\n        return header.set('Authorization', 'bearer ' + token);\n    }\n\n    private getLogoutOptions(): object {\n        const oauth2Config = this.appConfig.get<OauthConfigModel>(AppConfigValues.OAUTHCONFIG, null);\n        const logoutParamsList = oauth2Config?.logoutParameters || [];\n\n        return logoutParamsList.reduce((options, param) => {\n            const value = this.getLogoutParamValue(param);\n            if (value !== undefined) {\n                options[param] = value;\n            }\n            return options;\n        }, {});\n    }\n\n    private getLogoutParamValue(param: string): string | undefined {\n        switch (param) {\n            case 'client_id':\n                return this.oauthService.clientId;\n            case 'returnTo':\n                return this.oauthService.redirectUri;\n            case 'redirect_uri':\n                return this.oauthService.redirectUri;\n            case 'response_type':\n                return 'code';\n            default:\n                return undefined;\n        }\n    }\n}\n"]}

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

@@ -0,0 +1,24 @@
+/*!
+ * @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 './auth-routing.module';
+export * from './auth.module';
+export * from './auth.service';
+export * from './oidc-auth.guard';
+export * from './redirect-auth.service';
+export * from './view/authentication-confirmation/authentication-confirmation.component';
+export * from './oidc-authentication.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb3JlL3NyYy9saWIvYXV0aC9vaWRjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDBFQUEwRSxDQUFDO0FBQ3pGLGNBQWMsK0JBQStCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vYXV0aC1yb3V0aW5nLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2F1dGgubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vYXV0aC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vb2lkYy1hdXRoLmd1YXJkJztcbmV4cG9ydCAqIGZyb20gJy4vcmVkaXJlY3QtYXV0aC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vdmlldy9hdXRoZW50aWNhdGlvbi1jb25maXJtYXRpb24vYXV0aGVudGljYXRpb24tY29uZmlybWF0aW9uLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL29pZGMtYXV0aGVudGljYXRpb24uc2VydmljZSc7XG4iXX0=