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

package/esm2022/lib/auth/services/jwt-helper.service.mjs

@@ -0,0 +1,205 @@
+/*!
+ * @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 { OAuthStorage } from 'angular-oauth2-oidc';
+import * as i0 from "@angular/core";
+export class JwtHelperService {
+    constructor() {
+        this.storageService = inject(OAuthStorage);
+    }
+    static { this.USER_NAME = 'name'; }
+    static { this.FAMILY_NAME = 'family_name'; }
+    static { this.GIVEN_NAME = 'given_name'; }
+    static { this.USER_EMAIL = 'email'; }
+    static { this.USER_ACCESS_TOKEN = 'access_token'; }
+    static { this.USER_ID_TOKEN = 'id_token'; }
+    static { this.REALM_ACCESS = 'realm_access'; }
+    static { this.RESOURCE_ACCESS = 'resource_access'; }
+    static { this.USER_PREFERRED_USERNAME = 'preferred_username'; }
+    static { this.HXP_AUTHORIZATION = 'hxp_authorization'; }
+    /**
+     * Decodes a JSON web token into a JS object.
+     *
+     * @param token Token in encoded form
+     * @returns Decoded token data object
+     */
+    decodeToken(token) {
+        const parts = token.split('.');
+        if (parts.length !== 3) {
+            throw new Error('JWT must have 3 parts');
+        }
+        const decoded = this.urlBase64Decode(parts[1]);
+        if (!decoded) {
+            throw new Error('Cannot decode the token');
+        }
+        return JSON.parse(decoded);
+    }
+    urlBase64Decode(token) {
+        let output = token.replace(/-/g, '+').replace(/_/g, '/');
+        switch (output.length % 4) {
+            case 0: {
+                break;
+            }
+            case 2: {
+                output += '==';
+                break;
+            }
+            case 3: {
+                output += '=';
+                break;
+            }
+            default: {
+                throw new Error('Illegal base64url string!');
+            }
+        }
+        return decodeURIComponent(escape(window.atob(output)));
+    }
+    /**
+     * Gets a named value from the user access or id token.
+     *
+     * @param key Key name of the field to retrieve
+     * @returns Value from the token
+     */
+    getValueFromLocalToken(key) {
+        return this.getValueFromToken(this.getAccessToken(), key) || this.getValueFromToken(this.getIdToken(), key);
+    }
+    /**
+     * Gets a named value from the user access token.
+     *
+     * @param key Key name of the field to retrieve
+     * @returns Value from the token
+     */
+    getValueFromLocalAccessToken(key) {
+        return this.getValueFromToken(this.getAccessToken(), key);
+    }
+    /**
+     * Gets access token
+     *
+     * @returns access token
+     */
+    getAccessToken() {
+        return this.storageService.getItem(JwtHelperService.USER_ACCESS_TOKEN);
+    }
+    /**
+     * Gets a named value from the user id token.
+     *
+     * @param key Key name of the field to retrieve
+     * @returns Value from the token
+     */
+    getValueFromLocalIdToken(key) {
+        return this.getValueFromToken(this.getIdToken(), key);
+    }
+    /**
+     * Gets id token
+     *
+     * @returns id token
+     */
+    getIdToken() {
+        return this.storageService.getItem(JwtHelperService.USER_ID_TOKEN);
+    }
+    /**
+     * Gets a named value from the user access token.
+     *
+     * @param token your SSO access token where the value is encode
+     * @param key Key name of the field to retrieve
+     * @returns Value from the token
+     */
+    getValueFromToken(token, key) {
+        let value;
+        if (token) {
+            const tokenPayload = this.decodeToken(token);
+            value = tokenPayload[key];
+        }
+        return value;
+    }
+    /**
+     * Gets realm roles.
+     *
+     * @returns Array of realm roles
+     */
+    getRealmRoles() {
+        const access = this.getValueFromLocalAccessToken(JwtHelperService.REALM_ACCESS);
+        return access ? access['roles'] : [];
+    }
+    /**
+     * Gets Client roles.
+     *
+     * @param clientName client name
+     * @returns Array of client roles
+     */
+    getClientRoles(clientName) {
+        const clientRole = this.getValueFromLocalAccessToken(JwtHelperService.RESOURCE_ACCESS)[clientName];
+        return clientRole ? clientRole['roles'] : [];
+    }
+    /**
+     * Checks for single realm role.
+     *
+     * @param role Role name to check
+     * @returns True if it contains given role, false otherwise
+     */
+    hasRealmRole(role) {
+        let hasRole = false;
+        if (this.getAccessToken()) {
+            const realmRoles = this.getRealmRoles();
+            hasRole = realmRoles.some((currentRole) => currentRole === role);
+        }
+        return hasRole;
+    }
+    /**
+     * Checks for realm roles.
+     *
+     * @param rolesToCheck List of role names to check
+     * @returns True if it contains at least one of the given roles, false otherwise
+     */
+    hasRealmRoles(rolesToCheck) {
+        return rolesToCheck.some((currentRole) => this.hasRealmRole(currentRole));
+    }
+    /**
+     * Checks for client roles.
+     *
+     * @param clientName Targeted client name
+     * @param rolesToCheck List of role names to check
+     * @returns True if it contains at least one of the given roles, false otherwise
+     */
+    hasRealmRolesForClientRole(clientName, rolesToCheck) {
+        return rolesToCheck.some((currentRole) => this.hasClientRole(clientName, currentRole));
+    }
+    /**
+     * Checks for client role.
+     *
+     * @param clientName Targeted client name
+     * @param role Role name to check
+     * @returns True if it contains given role, false otherwise
+     */
+    hasClientRole(clientName, role) {
+        let hasRole = false;
+        if (this.getAccessToken()) {
+            const clientRoles = this.getClientRoles(clientName);
+            hasRole = clientRoles.some((currentRole) => currentRole === role);
+        }
+        return hasRole;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: JwtHelperService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: JwtHelperService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: JwtHelperService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jwt-helper.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/auth/services/jwt-helper.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 { OAuthStorage } from 'angular-oauth2-oidc';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class JwtHelperService {\n    static USER_NAME = 'name';\n    static FAMILY_NAME = 'family_name';\n    static GIVEN_NAME = 'given_name';\n    static USER_EMAIL = 'email';\n    static USER_ACCESS_TOKEN = 'access_token';\n    static USER_ID_TOKEN = 'id_token';\n    static REALM_ACCESS = 'realm_access';\n    static RESOURCE_ACCESS = 'resource_access';\n    static USER_PREFERRED_USERNAME = 'preferred_username';\n    static HXP_AUTHORIZATION = 'hxp_authorization';\n\n    private storageService: OAuthStorage = inject(OAuthStorage);\n\n    /**\n     * Decodes a JSON web token into a JS object.\n     *\n     * @param token Token in encoded form\n     * @returns Decoded token data object\n     */\n    decodeToken(token): any {\n        const parts = token.split('.');\n\n        if (parts.length !== 3) {\n            throw new Error('JWT must have 3 parts');\n        }\n\n        const decoded = this.urlBase64Decode(parts[1]);\n        if (!decoded) {\n            throw new Error('Cannot decode the token');\n        }\n\n        return JSON.parse(decoded);\n    }\n\n    private urlBase64Decode(token): string {\n        let output = token.replace(/-/g, '+').replace(/_/g, '/');\n        switch (output.length % 4) {\n            case 0: {\n                break;\n            }\n            case 2: {\n                output += '==';\n                break;\n            }\n            case 3: {\n                output += '=';\n                break;\n            }\n            default: {\n                throw new Error('Illegal base64url string!');\n            }\n        }\n        return decodeURIComponent(escape(window.atob(output)));\n    }\n\n    /**\n     * Gets a named value from the user access or id token.\n     *\n     * @param key Key name of the field to retrieve\n     * @returns Value from the token\n     */\n    getValueFromLocalToken<T>(key: string): T {\n        return this.getValueFromToken(this.getAccessToken(), key) || this.getValueFromToken(this.getIdToken(), key);\n    }\n\n    /**\n     * Gets a named value from the user access token.\n     *\n     * @param key Key name of the field to retrieve\n     * @returns Value from the token\n     */\n    getValueFromLocalAccessToken<T>(key: string): T {\n        return this.getValueFromToken(this.getAccessToken(), key);\n    }\n\n    /**\n     * Gets access token\n     *\n     * @returns access token\n     */\n    getAccessToken(): string {\n        return this.storageService.getItem(JwtHelperService.USER_ACCESS_TOKEN);\n    }\n\n    /**\n     * Gets a named value from the user id token.\n     *\n     * @param key Key name of the field to retrieve\n     * @returns Value from the token\n     */\n    getValueFromLocalIdToken<T>(key: string): T {\n        return this.getValueFromToken(this.getIdToken(), key);\n    }\n\n    /**\n     * Gets id token\n     *\n     * @returns id token\n     */\n    getIdToken(): string {\n        return this.storageService.getItem(JwtHelperService.USER_ID_TOKEN);\n    }\n\n    /**\n     * Gets a named value from the user access token.\n     *\n     * @param token your SSO access token where the value is encode\n     * @param key Key name of the field to retrieve\n     * @returns Value from the token\n     */\n    getValueFromToken<T>(token: string, key: string): T {\n        let value: T;\n\n        if (token) {\n            const tokenPayload = this.decodeToken(token);\n            value = tokenPayload[key];\n        }\n        return value;\n    }\n\n    /**\n     * Gets realm roles.\n     *\n     * @returns Array of realm roles\n     */\n    getRealmRoles(): string[] {\n        const access = this.getValueFromLocalAccessToken<any>(JwtHelperService.REALM_ACCESS);\n        return access ? access['roles'] : [];\n    }\n\n    /**\n     * Gets Client roles.\n     *\n     * @param clientName client name\n     * @returns Array of client roles\n     */\n    getClientRoles(clientName: string): string[] {\n        const clientRole = this.getValueFromLocalAccessToken<any>(JwtHelperService.RESOURCE_ACCESS)[clientName];\n        return clientRole ? clientRole['roles'] : [];\n    }\n\n    /**\n     * Checks for single realm role.\n     *\n     * @param role Role name to check\n     * @returns True if it contains given role, false otherwise\n     */\n    hasRealmRole(role: string): boolean {\n        let hasRole = false;\n        if (this.getAccessToken()) {\n            const realmRoles = this.getRealmRoles();\n            hasRole = realmRoles.some((currentRole) => currentRole === role);\n        }\n        return hasRole;\n    }\n\n    /**\n     * Checks for realm roles.\n     *\n     * @param rolesToCheck List of role names to check\n     * @returns True if it contains at least one of the given roles, false otherwise\n     */\n    hasRealmRoles(rolesToCheck: string[]): boolean {\n        return rolesToCheck.some((currentRole) => this.hasRealmRole(currentRole));\n    }\n\n    /**\n     * Checks for client roles.\n     *\n     * @param clientName Targeted client name\n     * @param rolesToCheck List of role names to check\n     * @returns True if it contains at least one of the given roles, false otherwise\n     */\n    hasRealmRolesForClientRole(clientName: string, rolesToCheck: string[]): boolean {\n        return rolesToCheck.some((currentRole) => this.hasClientRole(clientName, currentRole));\n    }\n\n    /**\n     * Checks for client role.\n     *\n     * @param clientName Targeted client name\n     * @param role Role name to check\n     * @returns True if it contains given role, false otherwise\n     */\n    hasClientRole(clientName: string, role: string): boolean {\n        let hasRole = false;\n        if (this.getAccessToken()) {\n            const clientRoles = this.getClientRoles(clientName);\n            hasRole = clientRoles.some((currentRole) => currentRole === role);\n        }\n        return hasRole;\n    }\n}\n"]}

package/esm2022/lib/auth/services/oauth2.service.mjs

@@ -0,0 +1,69 @@
+/*!
+ * @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 { from } from 'rxjs';
+import { AdfHttpClient } from '@alfresco/adf-core/api';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core/api";
+export const JSON_TYPE = ['application/json'];
+export class OAuth2Service {
+    constructor(adfHttpClient) {
+        this.adfHttpClient = adfHttpClient;
+    }
+    request(opts) {
+        const { httpMethod, url, bodyParam, queryParams } = opts;
+        return from(this.adfHttpClient.request(url, {
+            httpMethod,
+            queryParams,
+            headerParams: {},
+            formParams: {},
+            bodyParam,
+            returnType: Object
+        }));
+    }
+    get(opts) {
+        return this.request({
+            ...opts,
+            httpMethod: 'GET'
+        });
+    }
+    put(opts) {
+        return this.request({
+            ...opts,
+            httpMethod: 'PUT'
+        });
+    }
+    post(opts) {
+        return this.request({
+            ...opts,
+            httpMethod: 'POST'
+        });
+    }
+    delete(opts) {
+        return this.request({
+            ...opts,
+            httpMethod: 'DELETE'
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OAuth2Service, deps: [{ token: i1.AdfHttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OAuth2Service, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: OAuth2Service, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.AdfHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth/services/time-sync.service.mjs

@@ -0,0 +1,83 @@
+/*!
+ * @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 { HttpClient } from '@angular/common/http';
+import { Injectable, Injector } from '@angular/core';
+import { AppConfigService } from '../../app-config/app-config.service';
+import { from, throwError } from 'rxjs';
+import { catchError, map, timeout } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../app-config/app-config.service";
+export class TimeSyncService {
+    constructor(_injector, _appConfigService) {
+        this._injector = _injector;
+        this._appConfigService = _appConfigService;
+        this._http = this._injector.get(HttpClient);
+    }
+    checkTimeSync(maxAllowedClockSkewInSec) {
+        const startTime = Date.now();
+        return this.getServerTime().pipe(map((serverTimeResponse) => {
+            let serverTimeInMs;
+            const endTime = Date.now();
+            const roundTripTimeInMs = endTime - startTime;
+            const isServerTimeResponseInMs = serverTimeResponse.toString().length === 13;
+            if (!isServerTimeResponseInMs) {
+                serverTimeInMs = serverTimeResponse * 1000;
+            }
+            else {
+                serverTimeInMs = serverTimeResponse;
+            }
+            const adjustedServerTimeInMs = serverTimeInMs + roundTripTimeInMs / 2;
+            const localCurrentTimeInMs = Date.now();
+            const timeOffsetInMs = Math.abs(localCurrentTimeInMs - adjustedServerTimeInMs);
+            const maxAllowedClockSkewInMs = maxAllowedClockSkewInSec * 1000;
+            return {
+                outOfSync: timeOffsetInMs > maxAllowedClockSkewInMs,
+                timeOffsetInSec: timeOffsetInMs / 1000,
+                localDateTimeISO: new Date(localCurrentTimeInMs).toISOString(),
+                serverDateTimeISO: new Date(adjustedServerTimeInMs).toISOString()
+            };
+        }), catchError((error) => throwError(() => new Error(error))));
+    }
+    /**
+     * Checks if the local time is out of sync with the server time.
+     *
+     * @param maxAllowedClockSkewInSec - The maximum allowed clock skew in seconds.
+     * @returns An Observable that emits a boolean indicating whether the local time is out of sync.
+     */
+    isLocalTimeOutOfSync(maxAllowedClockSkewInSec) {
+        return this.checkTimeSync(maxAllowedClockSkewInSec).pipe(map((sync) => sync.outOfSync));
+    }
+    getServerTime() {
+        return from(this._http.get(this.getServerTimeUrl())).pipe(timeout(5000), catchError(() => throwError(() => new Error('Failed to get server time'))));
+    }
+    getServerTimeUrl() {
+        const serverTimeUrl = this._appConfigService.get('serverTimeUrl', '');
+        if (!serverTimeUrl) {
+            throw new Error('serverTimeUrl is not configured.');
+        }
+        return serverTimeUrl;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TimeSyncService, deps: [{ token: i0.Injector }, { token: i1.AppConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TimeSyncService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TimeSyncService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i1.AppConfigService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time-sync.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/auth/services/time-sync.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 { HttpClient } from '@angular/common/http';\nimport { Injectable, Injector } from '@angular/core';\nimport { AppConfigService } from '../../app-config/app-config.service';\nimport { from, Observable, throwError } from 'rxjs';\nimport { catchError, map, timeout } from 'rxjs/operators';\n\nexport interface TimeSync {\n    outOfSync: boolean;\n    timeOutOfSyncInSec?: number;\n    localDateTimeISO: string;\n    serverDateTimeISO: string;\n}\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class TimeSyncService {\n    private readonly _http: HttpClient;\n\n    constructor(private _injector: Injector, private _appConfigService: AppConfigService) {\n        this._http = this._injector.get(HttpClient);\n    }\n\n    checkTimeSync(maxAllowedClockSkewInSec: number): Observable<TimeSync> {\n        const startTime = Date.now();\n\n        return this.getServerTime().pipe(\n            map((serverTimeResponse: number) => {\n                let serverTimeInMs: number;\n\n                const endTime = Date.now();\n                const roundTripTimeInMs = endTime - startTime;\n\n                const isServerTimeResponseInMs = serverTimeResponse.toString().length === 13;\n                if (!isServerTimeResponseInMs) {\n                    serverTimeInMs = serverTimeResponse * 1000;\n                } else {\n                    serverTimeInMs = serverTimeResponse;\n                }\n\n                const adjustedServerTimeInMs = serverTimeInMs + roundTripTimeInMs / 2;\n                const localCurrentTimeInMs = Date.now();\n                const timeOffsetInMs = Math.abs(localCurrentTimeInMs - adjustedServerTimeInMs);\n                const maxAllowedClockSkewInMs = maxAllowedClockSkewInSec * 1000;\n\n                return {\n                    outOfSync: timeOffsetInMs > maxAllowedClockSkewInMs,\n                    timeOffsetInSec: timeOffsetInMs / 1000,\n                    localDateTimeISO: new Date(localCurrentTimeInMs).toISOString(),\n                    serverDateTimeISO: new Date(adjustedServerTimeInMs).toISOString()\n                };\n            }),\n            catchError((error) => throwError(() => new Error(error)))\n        );\n    }\n\n    /**\n     * Checks if the local time is out of sync with the server time.\n     *\n     * @param maxAllowedClockSkewInSec - The maximum allowed clock skew in seconds.\n     * @returns An Observable that emits a boolean indicating whether the local time is out of sync.\n     */\n    isLocalTimeOutOfSync(maxAllowedClockSkewInSec: number): Observable<boolean> {\n        return this.checkTimeSync(maxAllowedClockSkewInSec).pipe(map((sync) => sync.outOfSync));\n    }\n\n    private getServerTime(): Observable<number> {\n        return from(this._http.get<number>(this.getServerTimeUrl())).pipe(\n            timeout(5000),\n            catchError(() => throwError(() => new Error('Failed to get server time')))\n        );\n    }\n\n    private getServerTimeUrl(): string {\n        const serverTimeUrl = this._appConfigService.get('serverTimeUrl', '');\n        if (!serverTimeUrl) {\n            throw new Error('serverTimeUrl is not configured.');\n        }\n        return serverTimeUrl;\n    }\n}\n"]}

package/esm2022/lib/auth/services/user-access.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 { Injectable } from '@angular/core';
+import { JwtHelperService } from './jwt-helper.service';
+import { AppConfigService } from '../../app-config/app-config.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./jwt-helper.service";
+import * as i2 from "../../app-config/app-config.service";
+export class UserAccessService {
+    constructor(jwtHelperService, appConfigService) {
+        this.jwtHelperService = jwtHelperService;
+        this.appConfigService = appConfigService;
+    }
+    fetchUserAccess() {
+        if (this.hasRolesInRealmAccess()) {
+            this.fetchAccessFromRealmAccess();
+        }
+        else if (this.hasRolesInHxpAuthorization()) {
+            this.fetchAccessFromHxpAuthorization();
+        }
+    }
+    fetchAccessFromRealmAccess() {
+        this.globalAccess = this.jwtHelperService.getValueFromLocalToken(JwtHelperService.REALM_ACCESS).roles;
+        this.applicationAccess = this.jwtHelperService.getValueFromLocalToken(JwtHelperService.RESOURCE_ACCESS);
+    }
+    fetchAccessFromHxpAuthorization() {
+        this.globalAccess = [];
+        const hxpAuthorization = this.jwtHelperService.getValueFromLocalToken(JwtHelperService.HXP_AUTHORIZATION);
+        if (hxpAuthorization?.appkey && hxpAuthorization?.role) {
+            this.applicationAccess = [
+                {
+                    name: hxpAuthorization.appkey,
+                    roles: hxpAuthorization.role
+                }
+            ];
+        }
+        else {
+            this.applicationAccess = [];
+        }
+    }
+    hasRolesInRealmAccess() {
+        return !!this.jwtHelperService.getValueFromLocalToken(JwtHelperService.REALM_ACCESS);
+    }
+    hasRolesInHxpAuthorization() {
+        return !!this.jwtHelperService.getValueFromLocalToken(JwtHelperService.HXP_AUTHORIZATION);
+    }
+    /**
+     * Checks for global roles access.
+     *
+     * @param rolesToCheck List of the roles to check
+     * @returns True if it contains at least one of the given roles, false otherwise
+     */
+    hasGlobalAccess(rolesToCheck) {
+        if (rolesToCheck?.length > 0) {
+            if (this.hasRolesInRealmAccess()) {
+                return this.globalAccess ? this.globalAccess.some((role) => rolesToCheck.includes(role)) : false;
+            }
+            else if (this.hasRolesInHxpAuthorization()) {
+                return this.isCurrentAppKeyInToken() ? this.applicationAccess[0]?.roles.some((role) => rolesToCheck.includes(role)) : false;
+            }
+        }
+        else {
+            return true;
+        }
+        return false;
+    }
+    isCurrentAppKeyInToken() {
+        const currentAppKey = this.appConfigService.get('application.key');
+        return this.applicationAccess?.length ? currentAppKey === this.applicationAccess[0]?.name : false;
+    }
+    /**
+     * Checks for global roles access.
+     *
+     * @param appName The app name
+     * @param rolesToCheck List of the roles to check
+     * @returns True if it contains at least one of the given roles, false otherwise
+     */
+    hasApplicationAccess(appName, rolesToCheck) {
+        if (rolesToCheck?.length > 0) {
+            const appAccess = this.hasRolesInRealmAccess()
+                ? this.applicationAccess[appName]
+                : this.applicationAccess.find((app) => app.name === appName);
+            return appAccess ? appAccess.roles.some((appRole) => rolesToCheck.includes(appRole)) : false;
+        }
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserAccessService, deps: [{ token: i1.JwtHelperService }, { token: i2.AppConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserAccessService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserAccessService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.JwtHelperService }, { type: i2.AppConfigService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-access.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/auth/services/user-access.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 { JwtHelperService } from './jwt-helper.service';\nimport { ApplicationAccessModel } from '../models/application-access.model';\nimport { AppConfigService } from '../../app-config/app-config.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class UserAccessService {\n    private globalAccess: string[];\n    private applicationAccess: ApplicationAccessModel[];\n\n    constructor(private jwtHelperService: JwtHelperService, private appConfigService: AppConfigService) {}\n\n    fetchUserAccess() {\n        if (this.hasRolesInRealmAccess()) {\n            this.fetchAccessFromRealmAccess();\n        } else if (this.hasRolesInHxpAuthorization()) {\n            this.fetchAccessFromHxpAuthorization();\n        }\n    }\n\n    private fetchAccessFromRealmAccess() {\n        this.globalAccess = this.jwtHelperService.getValueFromLocalToken<any>(JwtHelperService.REALM_ACCESS).roles;\n        this.applicationAccess = this.jwtHelperService.getValueFromLocalToken<any>(JwtHelperService.RESOURCE_ACCESS);\n    }\n\n    private fetchAccessFromHxpAuthorization() {\n        this.globalAccess = [];\n        const hxpAuthorization = this.jwtHelperService.getValueFromLocalToken<any>(JwtHelperService.HXP_AUTHORIZATION);\n        if (hxpAuthorization?.appkey && hxpAuthorization?.role) {\n            this.applicationAccess = [\n                {\n                    name: hxpAuthorization.appkey,\n                    roles: hxpAuthorization.role\n                }\n            ];\n        } else {\n            this.applicationAccess = [];\n        }\n    }\n\n    private hasRolesInRealmAccess(): boolean {\n        return !!this.jwtHelperService.getValueFromLocalToken(JwtHelperService.REALM_ACCESS);\n    }\n\n    private hasRolesInHxpAuthorization(): boolean {\n        return !!this.jwtHelperService.getValueFromLocalToken(JwtHelperService.HXP_AUTHORIZATION);\n    }\n\n    /**\n     * Checks for global roles access.\n     *\n     * @param rolesToCheck List of the roles to check\n     * @returns True if it contains at least one of the given roles, false otherwise\n     */\n    hasGlobalAccess(rolesToCheck: string[]): boolean {\n        if (rolesToCheck?.length > 0) {\n            if (this.hasRolesInRealmAccess()) {\n                return this.globalAccess ? this.globalAccess.some((role: string) => rolesToCheck.includes(role)) : false;\n            } else if (this.hasRolesInHxpAuthorization()) {\n                return this.isCurrentAppKeyInToken() ? this.applicationAccess[0]?.roles.some((role: string) => rolesToCheck.includes(role)) : false;\n            }\n        } else {\n            return true;\n        }\n        return false;\n    }\n\n    private isCurrentAppKeyInToken(): boolean {\n        const currentAppKey = this.appConfigService.get('application.key');\n        return this.applicationAccess?.length ? currentAppKey === this.applicationAccess[0]?.name : false;\n    }\n\n    /**\n     * Checks for global roles access.\n     *\n     * @param appName The app name\n     * @param rolesToCheck List of the roles to check\n     * @returns True if it contains at least one of the given roles, false otherwise\n     */\n    hasApplicationAccess(appName: string, rolesToCheck: string[]): boolean {\n        if (rolesToCheck?.length > 0) {\n            const appAccess = this.hasRolesInRealmAccess()\n                ? this.applicationAccess[appName]\n                : this.applicationAccess.find((app: ApplicationAccessModel) => app.name === appName);\n            return appAccess ? appAccess.roles.some((appRole) => rolesToCheck.includes(appRole)) : false;\n        }\n        return true;\n    }\n}\n"]}

package/esm2022/lib/avatar/avatar.component.mjs

@@ -0,0 +1,51 @@
+/*!
+ * @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 { Component, HostBinding, Input, ViewEncapsulation } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class AvatarComponent {
+    constructor() {
+        this.initials = 'U';
+        this.tooltip = '';
+        this.size = getComputedStyle(document.documentElement).getPropertyValue('--adf-avatar-size');
+        this.cursor = getComputedStyle(document.documentElement).getPropertyValue('--adf-avatar-cursor');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AvatarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: AvatarComponent, isStandalone: true, selector: "adf-avatar", inputs: { src: "src", initials: "initials", tooltip: "tooltip", size: "size", cursor: "cursor" }, host: { properties: { "style.--adf-avatar-size": "this.size", "style.--adf-avatar-cursor": "this.cursor" } }, ngImport: i0, template: "<div class=\"adf-avatar\">\n    <img (error)=\"src = ''\" *ngIf=\"src; else initialsTemplate\" class=\"adf-avatar__image\" [src]=\"src\" [alt]=\"initials\" [title]=\"tooltip\" />\n</div>\n\n<ng-template #initialsTemplate>\n    <div class=\"adf-avatar__image adf-avatar__initials\" [title]=\"tooltip\">{{ initials }}</div>\n</ng-template>\n", styles: [".adf-avatar{display:flex}.adf-avatar__image{cursor:var(--adf-avatar-cursor, auto);display:inline-block;overflow:hidden;line-height:1;border-radius:var(--adf-avatar-border-radius, 50%);width:var(--adf-avatar-size, 32px);height:var(--adf-avatar-size, 32px);color:var(--adf-avatar-color, #333);background-color:var(--adf-avatar-background-color, #f3f3f3);box-shadow:0 0 0 1px var(--adf-avatar-border-color, rgba(31, 35, 40, .15));font-size:var(--adf-avatar-font-size, 14px);font-weight:var(--adf-avatar-font-weight, 500);text-align:center;align-content:center}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AvatarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-avatar', standalone: true, imports: [CommonModule], encapsulation: ViewEncapsulation.None, template: "<div class=\"adf-avatar\">\n    <img (error)=\"src = ''\" *ngIf=\"src; else initialsTemplate\" class=\"adf-avatar__image\" [src]=\"src\" [alt]=\"initials\" [title]=\"tooltip\" />\n</div>\n\n<ng-template #initialsTemplate>\n    <div class=\"adf-avatar__image adf-avatar__initials\" [title]=\"tooltip\">{{ initials }}</div>\n</ng-template>\n", styles: [".adf-avatar{display:flex}.adf-avatar__image{cursor:var(--adf-avatar-cursor, auto);display:inline-block;overflow:hidden;line-height:1;border-radius:var(--adf-avatar-border-radius, 50%);width:var(--adf-avatar-size, 32px);height:var(--adf-avatar-size, 32px);color:var(--adf-avatar-color, #333);background-color:var(--adf-avatar-background-color, #f3f3f3);box-shadow:0 0 0 1px var(--adf-avatar-border-color, rgba(31, 35, 40, .15));font-size:var(--adf-avatar-font-size, 14px);font-weight:var(--adf-avatar-font-weight, 500);text-align:center;align-content:center}\n"] }]
+        }], propDecorators: { src: [{
+                type: Input
+            }], initials: [{
+                type: Input
+            }], tooltip: [{
+                type: Input
+            }], size: [{
+                type: HostBinding,
+                args: ['style.--adf-avatar-size']
+            }, {
+                type: Input
+            }], cursor: [{
+                type: HostBinding,
+                args: ['style.--adf-avatar-cursor']
+            }, {
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/blank-page/blank-page.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 { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BlankPageComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BlankPageComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: BlankPageComponent, isStandalone: true, selector: "adf-blank-page", ngImport: i0, template: ``, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BlankPageComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'adf-blank-page',
+                    standalone: true,
+                    template: ``
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxhbmstcGFnZS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29yZS9zcmMvbGliL2JsYW5rLXBhZ2UvYmxhbmstcGFnZS5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFPMUMsTUFBTSxPQUFPLGtCQUFrQjsrR0FBbEIsa0JBQWtCO21HQUFsQixrQkFBa0IsMEVBRmpCLEVBQUU7OzRGQUVILGtCQUFrQjtrQkFMOUIsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsZ0JBQWdCO29CQUMxQixVQUFVLEVBQUUsSUFBSTtvQkFDaEIsUUFBUSxFQUFFLEVBQUU7aUJBQ2YiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmltcG9ydCB7IENvbXBvbmVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogJ2FkZi1ibGFuay1wYWdlJyxcbiAgICBzdGFuZGFsb25lOiB0cnVlLFxuICAgIHRlbXBsYXRlOiBgYFxufSlcbmV4cG9ydCBjbGFzcyBCbGFua1BhZ2VDb21wb25lbnQge31cbiJdfQ==