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

package/esm2022/lib/app-config/debug-app-config.service.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.
+ */
+import { Injectable } from '@angular/core';
+import { StorageService } from '../common/services/storage.service';
+import { AppConfigService, AppConfigValues } from './app-config.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../common/services/storage.service";
+export class DebugAppConfigService extends AppConfigService {
+    constructor(storage) {
+        super();
+        this.storage = storage;
+    }
+    get(key, defaultValue) {
+        if (key === AppConfigValues.OAUTHCONFIG) {
+            return JSON.parse(this.storage.getItem(key)) || super.get(key, defaultValue);
+        }
+        else if (key === AppConfigValues.APPLICATION) {
+            return undefined;
+        }
+        else {
+            return this.storage.getItem(key) || super.get(key, defaultValue);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DebugAppConfigService, deps: [{ token: i1.StorageService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DebugAppConfigService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DebugAppConfigService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.StorageService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/app-config/index.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @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 './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29yZS9zcmMvbGliL2FwcC1jb25maWcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/lib/app-config/public-api.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.
+ */
+export * from './app-config.service';
+export * from './debug-app-config.service';
+export * from './app-config.pipe';
+export * from './app-config-storage-prefix.factory';
+export * from './app-config.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb3JlL3NyYy9saWIvYXBwLWNvbmZpZy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMscUNBQXFDLENBQUM7QUFFcEQsY0FBYyxxQkFBcUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9hcHAtY29uZmlnLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9kZWJ1Zy1hcHAtY29uZmlnLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9hcHAtY29uZmlnLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9hcHAtY29uZmlnLXN0b3JhZ2UtcHJlZml4LmZhY3RvcnknO1xuXG5leHBvcnQgKiBmcm9tICcuL2FwcC1jb25maWcubW9kdWxlJztcbiJdfQ==

package/esm2022/lib/auth/authentication-interceptor/auth-bearer.interceptor.mjs

@@ -0,0 +1,67 @@
+/*!
+ * @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 { throwError as observableThrowError } from 'rxjs';
+import { Injectable } from '@angular/core';
+import { catchError, mergeMap } from 'rxjs/operators';
+import { AuthenticationService } from '../services/authentication.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/authentication.service";
+export class AuthBearerInterceptor {
+    constructor(authenticationService) {
+        this.authenticationService = authenticationService;
+        this._bearerExcludedUrls = ['resources/', 'assets/', 'auth/realms', 'idp/'];
+    }
+    loadExcludedUrlsRegex() {
+        const excludedUrls = this.bearerExcludedUrls;
+        this.excludedUrlsRegex = excludedUrls.map((urlPattern) => new RegExp(`^https?://[^/]+/${urlPattern}`, 'i')) || [];
+    }
+    intercept(req, next) {
+        if (!this.excludedUrlsRegex) {
+            this.loadExcludedUrlsRegex();
+        }
+        const requestUrl = req.url;
+        const shallPass = this.excludedUrlsRegex.some((regex) => regex.test(requestUrl));
+        if (shallPass) {
+            return next.handle(req).pipe(catchError((error) => observableThrowError(error)));
+        }
+        return this.authenticationService.addTokenToHeader(requestUrl, req.headers).pipe(mergeMap((headersWithBearer) => {
+            const headerWithContentType = this.appendJsonContentType(headersWithBearer, req.body);
+            const kcReq = req.clone({ headers: headerWithContentType });
+            return next.handle(kcReq).pipe(catchError((error) => observableThrowError(error)));
+        }));
+    }
+    appendJsonContentType(headers, reqBody) {
+        // prevent adding any content type, to properly handle formData with boundary browser generated value,
+        // as adding any Content-Type its going to break the upload functionality
+        if (headers.get('Content-Type') === 'multipart/form-data' && !(reqBody instanceof FormData)) {
+            return headers.delete('Content-Type');
+        }
+        if (!headers.get('Content-Type') && !(reqBody instanceof FormData)) {
+            return headers.set('Content-Type', 'application/json;charset=UTF-8');
+        }
+        return headers;
+    }
+    get bearerExcludedUrls() {
+        return this._bearerExcludedUrls;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthBearerInterceptor, deps: [{ token: i1.AuthenticationService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthBearerInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthBearerInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.AuthenticationService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth/basic-auth/basic-alfresco-auth.service.mjs

@@ -0,0 +1,356 @@
+/*!
+ * @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 { AppConfigService, AppConfigValues } from '../../app-config/app-config.service';
+import { CookieService } from '../../common/services/cookie.service';
+import { ContentAuth } from './content-auth';
+import { ProcessAuth } from './process-auth';
+import { catchError, map } from 'rxjs/operators';
+import { from } from 'rxjs';
+import { BaseAuthenticationService } from '../services/base-authentication.service';
+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 "./content-auth";
+import * as i4 from "./process-auth";
+const REMEMBER_ME_COOKIE_KEY = 'ALFRESCO_REMEMBER_ME';
+const REMEMBER_ME_UNTIL = 1000 * 60 * 60 * 24 * 30;
+export class BasicAlfrescoAuthService extends BaseAuthenticationService {
+    constructor(appConfig, cookie, contentAuth, processAuth) {
+        super(appConfig, cookie);
+        this.contentAuth = contentAuth;
+        this.processAuth = processAuth;
+        this.redirectUrl = null;
+        this.authentications = {
+            basicAuth: {
+                ticket: ''
+            },
+            type: 'basic'
+        };
+        this.appConfig.onLoad.subscribe(() => {
+            if (!this.isOauth() && this.isLoggedIn()) {
+                this.requireAlfTicket()
+                    .then(() => {
+                    this.onLogin.next('logged-in');
+                })
+                    .catch(() => {
+                    this.contentAuth.invalidateSession();
+                    this.onLogout.next('logout');
+                });
+            }
+        });
+        this.contentAuth.onLogout.pipe(map((event) => {
+            this.onLogout.next(event);
+        }));
+        this.contentAuth.onLogin.pipe(map((event) => {
+            this.onLogin.next(event);
+        }));
+        this.contentAuth.onError.pipe(map((event) => {
+            this.onError.next(event);
+        }));
+        this.processAuth.onLogout.pipe(map((event) => {
+            this.onLogout.next(event);
+        }));
+        this.processAuth.onLogin.pipe(map((event) => {
+            this.onLogin.next(event);
+        }));
+        this.processAuth.onError.pipe(map((event) => {
+            this.onError.next(event);
+        }));
+    }
+    /**
+     * Logs the user in.
+     *
+     * @param username Username for the login
+     * @param password Password for the login
+     * @param rememberMe Stores the user's login details if true
+     * @returns Object with auth type ("ECM", "BPM" or "ALL") and auth ticket
+     */
+    login(username, password, rememberMe = false) {
+        return from(this.executeLogin(username, password)).pipe(map((response) => {
+            this.saveRememberMeCookie(rememberMe);
+            this.onLogin.next(response);
+            return {
+                type: this.appConfig.get(AppConfigValues.PROVIDERS),
+                ticket: response
+            };
+        }), catchError((err) => this.handleError(err)));
+    }
+    /**
+     * login Alfresco API
+     *
+     * @param username username to login
+     * @param password password to login
+     * @returns A promise that returns {new authentication ticket} if resolved and {error} if rejected.
+     */
+    async executeLogin(username, password) {
+        if (!this.isCredentialValid(username) || !this.isCredentialValid(password)) {
+            return Promise.reject(new Error('missing username or password'));
+        }
+        if (username) {
+            username = username.trim();
+        }
+        if (this.isBPMProvider()) {
+            try {
+                return await this.processAuth.login(username, password);
+            }
+            catch (e) {
+                return Promise.reject(e);
+            }
+        }
+        else if (this.isECMProvider()) {
+            try {
+                return await this.contentAuth.login(username, password);
+            }
+            catch (e) {
+                return Promise.reject(e);
+            }
+        }
+        else if (this.isALLProvider()) {
+            return this.loginBPMECM(username, password);
+        }
+        else {
+            return Promise.reject(new Error('Unknown configuration'));
+        }
+    }
+    loginBPMECM(username, password) {
+        const contentPromise = this.contentAuth.login(username, password);
+        const processPromise = this.processAuth.login(username, password);
+        return new Promise((resolve, reject) => {
+            Promise.all([contentPromise, processPromise]).then((data) => {
+                this.onLogin.next('success');
+                resolve(data);
+            }, (error) => {
+                this.contentAuth.invalidateSession();
+                this.processAuth.invalidateSession();
+                if (error.status === 401) {
+                    this.onError.next('unauthorized');
+                }
+                this.onError.next('error');
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Checks whether the "remember me" cookie was set or not.
+     *
+     * @returns True if set, false otherwise
+     */
+    isRememberMeSet() {
+        return this.cookie.getItem(REMEMBER_ME_COOKIE_KEY) !== null;
+    }
+    /**
+     * Saves the "remember me" cookie as either a long-life cookie or a session cookie.
+     *
+     * @param rememberMe Enables a long-life cookie
+     */
+    saveRememberMeCookie(rememberMe) {
+        let expiration = null;
+        if (rememberMe) {
+            expiration = new Date();
+            const time = expiration.getTime();
+            const expireTime = time + REMEMBER_ME_UNTIL;
+            expiration.setTime(expireTime);
+        }
+        this.cookie.setItem(REMEMBER_ME_COOKIE_KEY, '1', expiration, null);
+    }
+    isCredentialValid(credential) {
+        return credential !== undefined && credential !== null && credential !== '';
+    }
+    getToken() {
+        if (this.isBPMProvider()) {
+            return this.processAuth.getToken();
+        }
+        else if (this.isECMProvider()) {
+            return this.contentAuth.getToken();
+        }
+        else if (this.isALLProvider()) {
+            return this.contentAuth.getToken();
+        }
+        else {
+            return '';
+        }
+    }
+    /**
+     * @deprecated
+     * @returns content auth token
+     */
+    getTicketEcm() {
+        return this.contentAuth.getToken();
+    }
+    /**
+     * @deprecated
+     * @returns process auth token
+     */
+    getTicketBpm() {
+        return this.processAuth.getToken();
+    }
+    isBpmLoggedIn() {
+        return this.processAuth.isLoggedIn();
+    }
+    isEcmLoggedIn() {
+        return this.contentAuth.isLoggedIn();
+    }
+    isLoggedIn() {
+        const authWithCredentials = this.isKerberosEnabled();
+        if (this.isBPMProvider()) {
+            return this.processAuth.isLoggedIn();
+        }
+        else if (this.isECMProvider()) {
+            return authWithCredentials ? true : this.contentAuth.isLoggedIn();
+        }
+        else if (this.isALLProvider()) {
+            return authWithCredentials ? true : this.contentAuth.isLoggedIn() && this.processAuth.isLoggedIn();
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * logout Alfresco API
+     *
+     * @returns A promise that returns {logout} if resolved and {error} if rejected.
+     */
+    async logout() {
+        if (this.isBPMProvider()) {
+            return this.processAuth.logout();
+        }
+        else if (this.isECMProvider()) {
+            return this.contentAuth.logout();
+        }
+        else if (this.isALLProvider()) {
+            return this.logoutBPMECM();
+        }
+        return Promise.resolve();
+    }
+    logoutBPMECM() {
+        const contentPromise = this.contentAuth.logout();
+        const processPromise = this.processAuth.logout();
+        return new Promise((resolve, reject) => {
+            Promise.all([contentPromise, processPromise]).then(() => {
+                this.contentAuth.ticket = undefined;
+                this.processAuth.ticket = undefined;
+                this.onLogout.next('logout');
+                resolve('logout');
+            }, (error) => {
+                if (error.status === 401) {
+                    this.onError.next('unauthorized');
+                }
+                this.onError.next('error');
+                reject(error);
+            });
+        });
+    }
+    reset() {
+        // do nothing
+    }
+    /**
+     * Gets the URL to redirect to after login.
+     *
+     * @returns The redirect URL
+     */
+    getRedirect() {
+        const provider = this.appConfig.get(AppConfigValues.PROVIDERS);
+        return this.hasValidRedirection(provider) ? this.redirectUrl.url : null;
+    }
+    setRedirect(url) {
+        this.redirectUrl = url;
+    }
+    hasValidRedirection(provider) {
+        return this.redirectUrl && (this.redirectUrl.provider === provider || this.hasSelectedProviderAll(provider));
+    }
+    hasSelectedProviderAll(provider) {
+        return this.redirectUrl && (this.redirectUrl.provider === 'ALL' || provider === 'ALL');
+    }
+    getBpmUsername() {
+        return this.processAuth.getUsername();
+    }
+    getEcmUsername() {
+        return this.contentAuth.getUsername();
+    }
+    getUsername() {
+        if (this.isBPMProvider()) {
+            return this.processAuth.getUsername();
+        }
+        else if (this.isECMProvider()) {
+            return this.contentAuth.getUsername();
+        }
+        else {
+            return this.contentAuth.getUsername();
+        }
+    }
+    /**
+     * Does kerberos enabled?
+     *
+     * @returns True if enabled, false otherwise
+     */
+    isKerberosEnabled() {
+        return this.appConfig.get(AppConfigValues.AUTH_WITH_CREDENTIALS, false);
+    }
+    getAuthHeaders(requestUrl, header) {
+        return this.addBasicAuth(requestUrl, header);
+    }
+    addBasicAuth(requestUrl, header) {
+        if (this.isKerberosEnabled()) {
+            return header;
+        }
+        const ticket = this.getTicketEcmBase64(requestUrl);
+        if (!ticket) {
+            return header;
+        }
+        return header.set('Authorization', ticket);
+    }
+    async requireAlfTicket() {
+        return this.contentAuth.requireAlfTicket();
+    }
+    /**
+     * Gets the BPM ticket from the Storage in Base 64 format.
+     *
+     * @param requestUrl the request url
+     * @returns The ticket or `null` if none was found
+     */
+    getTicketEcmBase64(requestUrl) {
+        let ticket = null;
+        const bpmRoot = `/${this.appConfig.get(AppConfigValues.CONTEXTROOTBPM) || 'activiti-app'}/`;
+        const ecmRoot = `/${this.appConfig.get(AppConfigValues.CONTEXTROOTECM) || 'alfresco'}/`;
+        if (requestUrl?.includes(ecmRoot) && !requestUrl.includes(bpmRoot)) {
+            ticket = this.getContentServicesTicket();
+        }
+        else if (requestUrl?.includes(bpmRoot) && !requestUrl.includes(ecmRoot)) {
+            ticket = this.getProcessServicesTicket();
+        }
+        else if (requestUrl?.includes(ecmRoot) && requestUrl.includes(bpmRoot)) {
+            ticket = requestUrl.indexOf(ecmRoot) < requestUrl.indexOf(bpmRoot) ? this.getContentServicesTicket() : this.getProcessServicesTicket();
+        }
+        return ticket;
+    }
+    getProcessServicesTicket() {
+        return this.processAuth.getToken()?.startsWith('Basic ') ? this.processAuth.getToken() : 'Basic ' + this.processAuth.getToken();
+    }
+    getContentServicesTicket() {
+        return 'Basic ' + btoa(this.contentAuth.getToken());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BasicAlfrescoAuthService, deps: [{ token: i1.AppConfigService }, { token: i2.CookieService }, { token: i3.ContentAuth }, { token: i4.ProcessAuth }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BasicAlfrescoAuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BasicAlfrescoAuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AppConfigService }, { type: i2.CookieService }, { type: i3.ContentAuth }, { type: i4.ProcessAuth }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"basic-alfresco-auth.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/auth/basic-auth/basic-alfresco-auth.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 { AppConfigService, AppConfigValues } from '../../app-config/app-config.service';\nimport { Authentication } from '../interfaces/authentication.interface';\nimport { CookieService } from '../../common/services/cookie.service';\nimport { ContentAuth } from './content-auth';\nimport { ProcessAuth } from './process-auth';\nimport { catchError, map } from 'rxjs/operators';\nimport { from, Observable } from 'rxjs';\nimport { RedirectionModel } from '../models/redirection.model';\nimport { BaseAuthenticationService } from '../services/base-authentication.service';\nimport { HttpHeaders } from '@angular/common/http';\n\nconst REMEMBER_ME_COOKIE_KEY = 'ALFRESCO_REMEMBER_ME';\nconst REMEMBER_ME_UNTIL = 1000 * 60 * 60 * 24 * 30;\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class BasicAlfrescoAuthService extends BaseAuthenticationService {\n    protected redirectUrl: RedirectionModel = null;\n\n    authentications: Authentication = {\n        basicAuth: {\n            ticket: ''\n        },\n        type: 'basic'\n    };\n\n    constructor(appConfig: AppConfigService, cookie: CookieService, private contentAuth: ContentAuth, private processAuth: ProcessAuth) {\n        super(appConfig, cookie);\n\n        this.appConfig.onLoad.subscribe(() => {\n            if (!this.isOauth() && this.isLoggedIn()) {\n                this.requireAlfTicket()\n                    .then(() => {\n                        this.onLogin.next('logged-in');\n                    })\n                    .catch(() => {\n                        this.contentAuth.invalidateSession();\n                        this.onLogout.next('logout');\n                    });\n            }\n        });\n\n        this.contentAuth.onLogout.pipe(\n            map((event) => {\n                this.onLogout.next(event);\n            })\n        );\n        this.contentAuth.onLogin.pipe(\n            map((event) => {\n                this.onLogin.next(event);\n            })\n        );\n        this.contentAuth.onError.pipe(\n            map((event) => {\n                this.onError.next(event);\n            })\n        );\n        this.processAuth.onLogout.pipe(\n            map((event) => {\n                this.onLogout.next(event);\n            })\n        );\n        this.processAuth.onLogin.pipe(\n            map((event) => {\n                this.onLogin.next(event);\n            })\n        );\n        this.processAuth.onError.pipe(\n            map((event) => {\n                this.onError.next(event);\n            })\n        );\n    }\n\n    /**\n     * Logs the user in.\n     *\n     * @param username Username for the login\n     * @param password Password for the login\n     * @param rememberMe Stores the user's login details if true\n     * @returns Object with auth type (\"ECM\", \"BPM\" or \"ALL\") and auth ticket\n     */\n    login(username: string, password: string, rememberMe: boolean = false): Observable<{ type: string; ticket: any }> {\n        return from(this.executeLogin(username, password)).pipe(\n            map((response: any) => {\n                this.saveRememberMeCookie(rememberMe);\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    /**\n     * login Alfresco API\n     *\n     * @param username username to login\n     * @param password password to login\n     * @returns A promise that returns {new authentication ticket} if resolved and {error} if rejected.\n     */\n    async executeLogin(username: string, password: string): Promise<any> {\n        if (!this.isCredentialValid(username) || !this.isCredentialValid(password)) {\n            return Promise.reject(new Error('missing username or password'));\n        }\n\n        if (username) {\n            username = username.trim();\n        }\n\n        if (this.isBPMProvider()) {\n            try {\n                return await this.processAuth.login(username, password);\n            } catch (e) {\n                return Promise.reject(e);\n            }\n        } else if (this.isECMProvider()) {\n            try {\n                return await this.contentAuth.login(username, password);\n            } catch (e) {\n                return Promise.reject(e);\n            }\n        } else if (this.isALLProvider()) {\n            return this.loginBPMECM(username, password);\n        } else {\n            return Promise.reject(new Error('Unknown configuration'));\n        }\n    }\n\n    private loginBPMECM(username: string, password: string): Promise<any> {\n        const contentPromise = this.contentAuth.login(username, password);\n        const processPromise = this.processAuth.login(username, password);\n\n        return new Promise((resolve, reject) => {\n            Promise.all([contentPromise, processPromise]).then(\n                (data) => {\n                    this.onLogin.next('success');\n                    resolve(data);\n                },\n                (error) => {\n                    this.contentAuth.invalidateSession();\n                    this.processAuth.invalidateSession();\n\n                    if (error.status === 401) {\n                        this.onError.next('unauthorized');\n                    }\n                    this.onError.next('error');\n                    reject(error);\n                }\n            );\n        });\n    }\n\n    /**\n     * Checks whether the \"remember me\" cookie was set or not.\n     *\n     * @returns True if set, false otherwise\n     */\n    isRememberMeSet(): boolean {\n        return this.cookie.getItem(REMEMBER_ME_COOKIE_KEY) !== null;\n    }\n\n    /**\n     * Saves the \"remember me\" cookie as either a long-life cookie or a session cookie.\n     *\n     * @param rememberMe Enables a long-life cookie\n     */\n    saveRememberMeCookie(rememberMe: boolean): void {\n        let expiration = null;\n\n        if (rememberMe) {\n            expiration = new Date();\n            const time = expiration.getTime();\n            const expireTime = time + REMEMBER_ME_UNTIL;\n            expiration.setTime(expireTime);\n        }\n        this.cookie.setItem(REMEMBER_ME_COOKIE_KEY, '1', expiration, null);\n    }\n\n    isCredentialValid(credential: string): boolean {\n        return credential !== undefined && credential !== null && credential !== '';\n    }\n\n    getToken(): string {\n        if (this.isBPMProvider()) {\n            return this.processAuth.getToken();\n        } else if (this.isECMProvider()) {\n            return this.contentAuth.getToken();\n        } else if (this.isALLProvider()) {\n            return this.contentAuth.getToken();\n        } else {\n            return '';\n        }\n    }\n\n    /**\n     * @deprecated\n     * @returns content auth token\n     */\n    getTicketEcm(): string {\n        return this.contentAuth.getToken();\n    }\n\n    /**\n     * @deprecated\n     * @returns process auth token\n     */\n    getTicketBpm(): string {\n        return this.processAuth.getToken();\n    }\n\n    isBpmLoggedIn(): boolean {\n        return this.processAuth.isLoggedIn();\n    }\n\n    isEcmLoggedIn(): boolean {\n        return this.contentAuth.isLoggedIn();\n    }\n\n    isLoggedIn(): boolean {\n        const authWithCredentials = this.isKerberosEnabled();\n\n        if (this.isBPMProvider()) {\n            return this.processAuth.isLoggedIn();\n        } else if (this.isECMProvider()) {\n            return authWithCredentials ? true : this.contentAuth.isLoggedIn();\n        } else if (this.isALLProvider()) {\n            return authWithCredentials ? true : this.contentAuth.isLoggedIn() && this.processAuth.isLoggedIn();\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * logout Alfresco API\n     *\n     * @returns A promise that returns {logout} if resolved and {error} if rejected.\n     */\n    async logout(): Promise<any> {\n        if (this.isBPMProvider()) {\n            return this.processAuth.logout();\n        } else if (this.isECMProvider()) {\n            return this.contentAuth.logout();\n        } else if (this.isALLProvider()) {\n            return this.logoutBPMECM();\n        }\n        return Promise.resolve();\n    }\n\n    private logoutBPMECM(): Promise<any> {\n        const contentPromise = this.contentAuth.logout();\n        const processPromise = this.processAuth.logout();\n\n        return new Promise((resolve, reject) => {\n            Promise.all([contentPromise, processPromise]).then(\n                () => {\n                    this.contentAuth.ticket = undefined;\n                    this.processAuth.ticket = undefined;\n                    this.onLogout.next('logout');\n                    resolve('logout');\n                },\n                (error) => {\n                    if (error.status === 401) {\n                        this.onError.next('unauthorized');\n                    }\n                    this.onError.next('error');\n                    reject(error);\n                }\n            );\n        });\n    }\n\n    reset(): void {\n        // do nothing\n    }\n\n    /**\n     * Gets the URL to redirect to after login.\n     *\n     * @returns The redirect URL\n     */\n    getRedirect(): string {\n        const provider = this.appConfig.get<string>(AppConfigValues.PROVIDERS);\n        return this.hasValidRedirection(provider) ? this.redirectUrl.url : null;\n    }\n\n    setRedirect(url?: RedirectionModel) {\n        this.redirectUrl = url;\n    }\n\n    private hasValidRedirection(provider: string): boolean {\n        return this.redirectUrl && (this.redirectUrl.provider === provider || this.hasSelectedProviderAll(provider));\n    }\n\n    private hasSelectedProviderAll(provider: string): boolean {\n        return this.redirectUrl && (this.redirectUrl.provider === 'ALL' || provider === 'ALL');\n    }\n\n    getBpmUsername(): string {\n        return this.processAuth.getUsername();\n    }\n\n    getEcmUsername(): string {\n        return this.contentAuth.getUsername();\n    }\n\n    getUsername(): string {\n        if (this.isBPMProvider()) {\n            return this.processAuth.getUsername();\n        } else if (this.isECMProvider()) {\n            return this.contentAuth.getUsername();\n        } else {\n            return this.contentAuth.getUsername();\n        }\n    }\n\n    /**\n     * Does kerberos enabled?\n     *\n     * @returns True if enabled, false otherwise\n     */\n    isKerberosEnabled(): boolean {\n        return this.appConfig.get<boolean>(AppConfigValues.AUTH_WITH_CREDENTIALS, false);\n    }\n\n    getAuthHeaders(requestUrl: string, header: HttpHeaders): HttpHeaders {\n        return this.addBasicAuth(requestUrl, header);\n    }\n\n    private addBasicAuth(requestUrl: string, header: HttpHeaders): HttpHeaders {\n        if (this.isKerberosEnabled()) {\n            return header;\n        }\n\n        const ticket = this.getTicketEcmBase64(requestUrl);\n\n        if (!ticket) {\n            return header;\n        }\n\n        return header.set('Authorization', ticket);\n    }\n\n    async requireAlfTicket(): Promise<void> {\n        return this.contentAuth.requireAlfTicket();\n    }\n\n    /**\n     * Gets the BPM ticket from the Storage in Base 64 format.\n     *\n     * @param requestUrl the request url\n     * @returns The ticket or `null` if none was found\n     */\n    getTicketEcmBase64(requestUrl: string): string | null {\n        let ticket = null;\n\n        const bpmRoot = `/${this.appConfig.get<string>(AppConfigValues.CONTEXTROOTBPM) || 'activiti-app'}/`;\n        const ecmRoot = `/${this.appConfig.get<string>(AppConfigValues.CONTEXTROOTECM) || 'alfresco'}/`;\n\n        if (requestUrl?.includes(ecmRoot) && !requestUrl.includes(bpmRoot)) {\n            ticket = this.getContentServicesTicket();\n        } else if (requestUrl?.includes(bpmRoot) && !requestUrl.includes(ecmRoot)) {\n            ticket = this.getProcessServicesTicket();\n        } else if (requestUrl?.includes(ecmRoot) && requestUrl.includes(bpmRoot)) {\n            ticket = requestUrl.indexOf(ecmRoot) < requestUrl.indexOf(bpmRoot) ? this.getContentServicesTicket() : this.getProcessServicesTicket();\n        }\n        return ticket;\n    }\n\n    private getProcessServicesTicket(): string {\n        return this.processAuth.getToken()?.startsWith('Basic ') ? this.processAuth.getToken() : 'Basic ' + this.processAuth.getToken();\n    }\n\n    private getContentServicesTicket(): string {\n        return 'Basic ' + btoa(this.contentAuth.getToken());\n    }\n}\n"]}