@albi_scando/as-backbone-lib 1.0.4 → 1.1.1

package/dist/as-backbone-lib/fesm2022/albi_scando-as-backbone-lib.mjs

@@ -1,11 +1,750 @@
+import { HttpClient, HttpEventType } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { inject, Injectable, signal, computed, Pipe } from '@angular/core';
+import { HTTP_HEADERS, HTTP_RESPONSE_STATUS_CODES } from '@albi_scando/as-const-http-lib';
+import { UserService as UserService$1 } from '@user/services/user/user.service';
+import { LoggerService } from '@albi_scando/as-log-lib';
+import { tap, catchError, throwError, of, forkJoin, defaultIfEmpty, map, take, defer, EMPTY, switchMap } from 'rxjs';
+import { LOCALE_ISO_CODES, LOCALES } from '@albi_scando/as-const-languages-lib';
+import { TRANSLATION_DELIBERATELY_UNSET } from '@albi_scando/as-const-lib/dist/types/constants/constants';
+import { HttpService as HttpService$1 } from '@http/services/http/http.service';
+import { STRING_EMPTY } from '@albi_scando/as-const-lib';
+
+class HttpService {
+    /**
+     * {@link HttpClient}
+     */
+    httpClient = inject(HttpClient);
+    /**
+     * {@link IHttpService.expiredPasswordFn}
+     */
+    expiredPasswordFn = () => undefined;
+    /**
+     * {@link IHttpService.unauthorizedFn}
+     */
+    unauthorizedFn = () => undefined;
+    /**
+     * Perform http delete request
+     *
+     * @param {Delete} httpRequest http request
+     * @returns {Observable<unknown>} response observable
+     */
+    delete(httpRequest) {
+        const options = this.typeSafeHeaderOptions(httpRequest.headerParams);
+        return this.httpClient.delete(httpRequest.url, options);
+    }
+    /**
+     * Perform http get request
+     *
+     * @param {Get} httpRequest http request
+     * @returns {Observable<unknown>} response observable
+     */
+    get(httpRequest) {
+        httpRequest.url = this._setQueryParams(httpRequest.queryParams, httpRequest.url);
+        const options = this.typeSafeHeaderOptions(httpRequest.headerParams);
+        return this.httpClient.get(httpRequest.url, options);
+    }
+    /**
+     * Perform http patch request
+     *
+     * @param {Patch} httpRequest http request
+     * @returns {Observable<unknown>} response observable
+     */
+    patch(httpRequest) {
+        const options = this.typeSafeHeaderOptions(httpRequest.headerParams);
+        return this.httpClient.patch(httpRequest.url, httpRequest.body, options);
+    }
+    /**
+     * Perform http post request
+     *
+     * @param {Post} httpRequest http request
+     * @returns {Observable<unknown>} response observable
+     */
+    post(httpRequest) {
+        const options = this.typeSafeHeaderOptions(httpRequest.headerParams);
+        return this.httpClient.post(httpRequest.url, httpRequest.body, options);
+    }
+    /**
+     * Perform http put request
+     *
+     * @param {Put} httpRequest http request
+     * @returns {Observable<unknown>} response observable
+     */
+    put(httpRequest) {
+        const options = this.typeSafeHeaderOptions(httpRequest.headerParams);
+        return this.httpClient.put(httpRequest.url, httpRequest.body, options);
+    }
+    /**
+     * Set url query parameters
+     *
+     * @param {Map<string, string>} queryParams query parameters key-value pairs
+     * @param {string} url original httpRequest url
+     * @returns {string} new url with aquery parameters
+     */
+    _setQueryParams(queryParams = new Map(), url) {
+        if (queryParams.size === 0) {
+            return url;
+        }
+        url += `?${Array.from(queryParams.entries()).map(([key, value]) => `${key}=${value}`).join('&')}`;
+        return url;
+    }
+    /**
+     * Type safe header options for HttpClient methods
+     * @param httpRequestHeaders header parameters key-value pairs
+     * @returns header options for HttpClient methods
+     */
+    typeSafeHeaderOptions(httpRequestHeaders) {
+        return { headers: Object.fromEntries(this._setHeaderParams(httpRequestHeaders)) };
+    }
+    /**
+     * Set http request header parameters
+     *
+     * @param {Map<HttpHeaders, string | boolean>} headerParams header parameters key-value pairs
+     * @returns {Map<HttpHeaders, string>} header parameters key-value pairs. All values must be strings.
+     */
+    _setHeaderParams(headerParams) {
+        if (headerParams === undefined || headerParams.size === 0) {
+            return new Map();
+        }
+        const headerParameters = new Map();
+        Array.from(headerParams.entries()).forEach(([key, value]) => {
+            headerParameters.set(key, `${value}`);
+        });
+        return headerParameters;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: HttpService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: HttpService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: HttpService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * This interceptor is responsible for adding Authorization header parameter to every outgoing HttpRequest
+ *
+ * @param {HttpRequest<unknown>} httpRequest @see {@link HttpRequest}
+ * @param {HttpHandlerFn} next @see {@link HttpHandlerFn}
+ * @returns {Observable<HttpEvent<unknown>>} @see {@link Observable<HttpEvent>}
+ */
+const authorizationInterceptor = (httpRequest, next) => {
+    /**
+     * {@link UserService}
+     */
+    const userService = inject(UserService$1);
+    const token = userService.token();
+    if (token === undefined) {
+        return next(httpRequest);
+    }
+    const clonedRequest = httpRequest.clone({
+        headers: httpRequest.headers.set(HTTP_HEADERS.AUTHORIZATION, token),
+    });
+    return next(clonedRequest);
+};
+
+/**
+ * This interceptor logs every outgoing HttpRequest.
+ * It fulfills the same task as the developer tools Network inspector.
+ *
+ * @param {HttpRequest<unknown>} httpRequest @see {@link HttpRequest}
+ * @param {HttpHandlerFn} next @see {@link HttpHandlerFn}
+ * @returns {Observable<HttpEvent<unknown>>} @see {@link Observable<HttpEvent>}
+ */
+const logRequestInterceptor = (httpRequest, next) => {
+    /**
+     * {@link LoggerService}
+     */
+    const loggerService = inject(LoggerService);
+    return next(httpRequest).pipe(tap(() => {
+        loggerService.debug(`${logRequestInterceptor.name}: - ${httpRequest.url} http request`, httpRequest);
+    }));
+};
+
+/**
+ * This interceptor logs the time interval (in milliseconds) between the request submission and the incoming response.
+ * It fulfills the same task as 'Waterfall' graph in the developer tools Network inspector.
+ *
+ * @param {HttpRequest<unknown>} httpRequest @see {@link HttpRequest}
+ * @param {HttpHandlerFn} next @see {@link HttpHandlerFn}
+ * @returns {Observable<HttpEvent<unknown>>} @see {@link Observable<HttpEvent>}
+ */
+const requestTimestampInterceptor = (httpRequest, next) => {
+    /**
+     * {@link LoggerService}
+     */
+    const loggerService = inject(LoggerService);
+    const startTime = Date.now();
+    const formatLog = (message, isError = false) => {
+        const diff = Date.now() - startTime;
+        const logMessage = `${requestTimestampInterceptor.name}: - ${httpRequest.url} ${message} in ${diff} ms`;
+        if (isError) {
+            loggerService.error(logMessage);
+        }
+        else {
+            loggerService.debug(logMessage);
+        }
+    };
+    return next(httpRequest).pipe(tap({
+        next: (event) => {
+            if (event.type === HttpEventType.Response) {
+                formatLog('succeeded');
+            }
+        },
+        error: () => {
+            formatLog('failed', true);
+        },
+    }));
+};
+
+const EXPIRED_PASSWORD_MESSAGE = 'Expired password';
+/**
+ * Http request interceptor to handle 401 unauthorized responses.
+ * 401 error is special, because it needs more than just a feedback.
+ * In most situations, it could be provoked by an expired token that requires a redirect to a 'Login' page.
+ * When validating credentials, it could be provoked by an expired password that requires a redirect to 'Change password' page.
+ *
+ * @param {HttpRequest<unknown>} httpRequest @see {@link HttpRequest}
+ * @param {HttpHandlerFn} next @see {@link HttpHandlerFn}
+ * @returns {Observable<HttpEvent<unknown>>} @see {@link : Observable<HttpEvent>}
+ */
+const unauthorizedInterceptor = (httpRequest, next) => {
+    const httpService = inject(HttpService);
+    return next(httpRequest).pipe(catchError((httpResponse) => {
+        if (httpResponse.status !== HTTP_RESPONSE_STATUS_CODES.UNAUTHORIZED) {
+            return throwError(() => httpResponse);
+        }
+        const errorMessage = httpResponse.error?.ErrMsg;
+        if (errorMessage === EXPIRED_PASSWORD_MESSAGE) {
+            httpService.expiredPasswordFn();
+        }
+        else {
+            httpService.unauthorizedFn();
+        }
+        return of();
+    }));
+};
+
+/**
+ * A service that manages translations based on the current language.
+ *
+ * The `TranslationsService` handles fetching, storing, and updating translations
+ * for different languages. It interacts with various translation sources and
+ * provides methods to retrieve translations based on a given key.
+ */
+class TranslationsService {
+    /**
+     * List of translations sources (apis/files)
+     */
+    _sources = new Set();
+    /**
+     * Current translations dictionary, mapping translation keys to their values.
+     */
+    translations = signal(new Map(), ...(ngDevMode ? [{ debugName: "translations" }] : /* istanbul ignore next */ []));
+    /**
+     * Derived signal that indicates whether translations are currently loaded.
+     * Returns true if the translations map contains any entries.
+     */
+    hasTranslations = computed(() => this.translations().size > 0, ...(ngDevMode ? [{ debugName: "hasTranslations" }] : /* istanbul ignore next */ []));
+    /**
+     * Derived signal for the count of currently loaded translations.
+     * Useful for debugging or monitoring translation load status.
+     */
+    translationsCount = computed(() => this.translations().size, ...(ngDevMode ? [{ debugName: "translationsCount" }] : /* istanbul ignore next */ []));
+    /**
+     * {@link HttpService}
+     */
+    httpService = inject(HttpService$1);
+    /**
+     * {@link LoggerService}
+     */
+    loggerService = inject(LoggerService);
+    /**
+     * Adds new translation sources and optionally updates translations for a given language code.
+     *
+     * If no language code is provided, the translations will not be updated immediately.
+     * The translations will be updated as soon as the current language is set.
+     *
+     * @param {Set<TranslationsSource>} sources New sources to add.
+     * @param {Locales} [language=stringEmpty] Optional language code to trigger translations update.
+     * @returns {Observable<void>} An observable that completes when the translations are updated.
+     */
+    addTranslationsSources$(sources, language) {
+        this._sources = new Set([...this._sources, ...sources]);
+        this.loggerService.debug(`Translations sources added`, this._sources);
+        return this.updateTranslations$(language, sources);
+    }
+    /**
+     * Updates translations based on the provided language code and sources.
+     *
+     * @param {Locales} language The language code to use for updating translations.
+     * @param {Set<TranslationsSource>} [sources=this._sources] Optional set of sources to update.
+     * @returns {Observable<void>} An observable that completes when the translations are updated.
+     */
+    updateTranslations$(language, sources = this._sources) {
+        const observables = this._getUpdateTranslationsObservables(language, sources);
+        return forkJoin(Array.from(observables)).pipe(defaultIfEmpty([]), map((responses) => {
+            this.translations.update(() => this._mergeMaps(this.translations(), ...responses));
+            this.loggerService.info(`${this.constructor.name} - Setup - Translations set`, this.translations());
+        }));
+    }
+    /**
+     * {@link ITranslationsService.translate}
+     */
+    translate(key) {
+        const keyExists = this.translations().has(key);
+        if (!keyExists) {
+            this.loggerService.warn(`${this.constructor.name} - '${key}' translation key does not exist.`);
+            return key;
+        }
+        const value = this.translations().get(key);
+        if (value === '' || value == null) {
+            this.loggerService.warn(`${this.constructor.name} - '${key}' translation value is missing.`);
+            return key;
+        }
+        if (value === TRANSLATION_DELIBERATELY_UNSET) {
+            return key;
+        }
+        return value.replace('\\n', '\n');
+    }
+    /**
+     * Merge all translations update observables into a single set object
+     * @param {Locales} language required language
+     * @param {string} sources source object
+     * @returns {Set<Observable<Map<string, string>>>} a set of translations
+     * @private
+     */
+    _getUpdateTranslationsObservables(language, sources) {
+        const observables = new Set();
+        sources.forEach((source) => {
+            const observable = this._fetchTranslations$(language, source);
+            observables.add(observable);
+        });
+        return observables;
+    }
+    /**
+     * Fetch translations process, from JSON file path or API url
+     * @param {Locales} language required language
+     * @param {string} source source object
+     * @returns {Observable<Map<string, string>>} a map with all required translations
+     * @private
+     */
+    _fetchTranslations$(language, source) {
+        const request = {
+            key: `translations:${language}:${source}`,
+            url: `${source}`,
+        };
+        const observable = this.httpService
+            .get(request)
+            .pipe(map((response) => this._filterTranslations(language, response)));
+        return observable;
+    }
+    /**
+     * API fetched translations are already filtered correctly by current language.
+     * JSON are not. Treat them equally and filter out unneeded translations.
+     *
+     * @example
+     * Generic JSON response is of type
+     *  {
+     *      key1: {
+     *          fr: 'frenchTranslatedValue',
+     *          en: 'englishTranslatedValue',
+     *          it: 'italianTranslatedValue'
+     *          ...
+     *      },
+     *      key2: {
+     *          fr: 'frenchTranslatedValue',
+     *          en: 'englishTranslatedValue',
+     *          it: 'italianTranslatedValue'
+     *          ...
+     *      },
+     *      ...
+     *  }
+     *
+     * If language is 'en', then original response will be filtered as follow
+     *
+     *  {
+     *      key1: 'englishTranslatedValue',
+     *      key2: 'englishTranslatedValue',
+     *      ...
+     *  }
+     *
+     * @param {Locales} language filter translations upon this language code
+     * @param {any} response fetched translations
+     * @returns {Translations} this source filtered translations
+     * @private
+     */
+    _filterTranslations(language, response) {
+        const isoCode = LOCALE_ISO_CODES[language];
+        const translations = new Map(Object.entries(Object.entries(response)
+            .map(([key, value]) => {
+            const val = value[isoCode];
+            return { [key]: val };
+        })
+            .reduce((acc, translation) => Object.assign(acc, translation), {})));
+        return translations;
+    }
+    /**
+     * Merge multiple map objects into single map
+     * @param {Map<K, V>[]} maps maps to merge
+     * @returns {Map<K, V>} merged maps
+     * @private
+     */
+    _mergeMaps(...maps) {
+        const mergedMap = new Map();
+        maps.forEach((map) => {
+            map.forEach((value, key) => {
+                mergedMap.set(key, value);
+            });
+        });
+        return mergedMap;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: TranslationsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: TranslationsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: TranslationsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * Pipe that transforms a key into a translated string based on the provided language.
+ * It allows to avoid calling function {@link TranslationsService.translate} in template
+ * (highly inefficient for function being triggered on every changeDetection), exploiting
+ * signal powerness.
+ */
+class TranslatePipe {
+    /**
+     * @type {TranslationsService}
+     */
+    translationsService = inject(TranslationsService);
+    /**
+     * Transforms the given key into the corresponding translation.
+     *
+     * @param {string} key The key for the translation.
+     * @returns {string} The translated string.
+     */
+    transform(key) {
+        return this.translationsService.translate(key);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: TranslatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.4", ngImport: i0, type: TranslatePipe, isStandalone: true, name: "translate" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: TranslatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'translate',
+                    standalone: true,
+                }]
+        }] });
+
+var languages = [
+	"fr",
+	"en",
+	"it"
+];
+var defaultConfigJSON$1 = {
+	languages: languages
+};
+
 /**
- * The name of the application.
+ * Default language
  */
-const APPLICATION_NAME = 'as-backbone-lib';
+const DEFAULT_LANGUAGE = LOCALES.ENGLISH_UNITED_KINGDOM;
+
+/**
+ * A service that manages different languages operations.
+ */
+class LanguageService {
+    /**
+     * Boolean value triggered when there is an ongoing language change process
+     */
+    isLoadingLanguage = signal(false, ...(ngDevMode ? [{ debugName: "isLoadingLanguage" }] : /* istanbul ignore next */ []));
+    /**
+     * Allowed locales
+     */
+    allowedLocales = new Set();
+    /**
+     * Derived signal for the current language/locale from the user service.
+     * Updates automatically when user's locale changes.
+     */
+    currentLanguage = computed(() => this.userService.locale(), ...(ngDevMode ? [{ debugName: "currentLanguage" }] : /* istanbul ignore next */ []));
+    /**
+     * {@link LoggerService}
+     */
+    loggerService = inject(LoggerService);
+    /**
+     * {@link TranslationsService}
+     */
+    translationsService = inject(TranslationsService);
+    /**
+     * {@link UserService}
+     */
+    userService = inject(UserService$1);
+    /**
+     * Constructor
+     * @constructor
+     * @ignore
+     */
+    constructor() {
+        const config = defaultConfigJSON$1;
+        const setup = {
+            locales: new Set(config['locales']),
+            currentLocale: config['currentLocale'],
+        };
+        this.setup$(setup).pipe(take(1)).subscribe();
+    }
+    /**
+     * {@link ILanguageService.setup$}
+     */
+    setup$(setup) {
+        return defer(() => {
+            if (setup.locales !== null && setup.locales !== undefined) {
+                this.setAllowedLanguages(setup.locales);
+            }
+            return setup.currentLocale !== null && setup.currentLocale !== undefined
+                ? this.setLanguage$(setup.currentLocale)
+                : this.setLanguage$();
+        });
+    }
+    /**
+     *  {@link ILanguageService.setAllowedLanguages}
+     */
+    setAllowedLanguages(locales) {
+        this.allowedLocales = locales;
+    }
+    /**
+     * {@link ILanguageService.setLanguage$}
+     */
+    setLanguage$(locale = undefined) {
+        if (locale !== null && locale !== undefined && this._isLanguageAllowed(locale) === false) {
+            this.loggerService.warn(`'${locale}' is not among valid locales. Going for auto locale.`);
+            locale = undefined;
+        }
+        if (locale === null || locale === undefined) {
+            locale = this._pickAutoLanguage();
+            this.loggerService.warn(`Auto locale set. Picked '${locale}'.`);
+        }
+        if (this._isLanguageAlreadySet(locale)) {
+            this.loggerService.warn(`'${locale}' locale is already set.`);
+            return EMPTY;
+        }
+        const resolvedLocale = locale;
+        return of(() => { this._toggleIsLoadingLanguage(true); }).pipe(tap(() => { this._updateUserLanguage(resolvedLocale); }), switchMap(() => this._updateTranslations$()), tap(() => { this._toggleIsLoadingLanguage(false); }));
+    }
+    /**
+     * Update user locale and sync
+     * @param {Locales} locale locale to set
+     * @returns {void}
+     * @private
+     */
+    _updateUserLanguage(locale) {
+        this.userService.setLocale(locale);
+    }
+    /**
+     * Update app translations according to current user locale
+     * @returns {Observable<void>}
+     * @private
+     */
+    _updateTranslations$() {
+        const locale = this.userService.locale();
+        if (locale === null || locale === undefined) {
+            this.loggerService.error(`User locale is not set. Cannot update translations.`);
+            return EMPTY;
+        }
+        return this.translationsService.updateTranslations$(locale);
+    }
+    /**
+     * Check if locale is already set
+     * @param {Locales} locale locale to set
+     * @returns {boolean} true if provided locale is already set
+     * @private
+     */
+    _isLanguageAlreadySet(locale) {
+        return locale === this.userService.locale();
+    }
+    /**
+     * Check if locale is among allowed ones
+     * @param {Locales} locale locale to set
+     * @returns {boolean} true if provided locale is among allowed ones
+     * @private
+     */
+    _isLanguageAllowed(locale) {
+        return this.allowedLocales.has(locale);
+    }
+    /**
+     * Pick a valid locale automatically.
+     * Try to get it from:
+     * 1. user locale
+     * 2. navigator locale
+     * 3. default locale (en)
+     * 4. first allowed locale
+     * @returns {Locales} allowed locale according to rules above.
+     * @private
+     */
+    _pickAutoLanguage() {
+        let language = this.userService.locale();
+        if (language === null || language === undefined || !this._isLanguageAllowed(language)) {
+            language = this._getNavigatorLanguage();
+            if (!this._isLanguageAllowed(language)) {
+                language = DEFAULT_LANGUAGE;
+                if (!this._isLanguageAllowed(language)) {
+                    language = [...this.allowedLocales][0];
+                }
+            }
+        }
+        return language;
+    }
+    /**
+     * Get navigator language
+     * @returns {Locales} navigator language 'it'/'fr'
+     * @private
+     */
+    _getNavigatorLanguage() {
+        const navigatorLocale = this._getNavigatorLocale();
+        return (navigatorLocale.includes('-')
+            ? navigatorLocale.split('-')[0]
+            : navigatorLocale);
+    }
+    /**
+     * Get navigator locale
+     * @returns {string} navigator locale 'it-IT'/'fr-FR'
+     * @private
+     */
+    _getNavigatorLocale() {
+        return window.navigator.language;
+    }
+    /**
+     * Toggle isLoadingNewLanguage property
+     * @param {boolean | null} value value to set
+     * @returns {void}
+     * @private
+     */
+    _toggleIsLoadingLanguage(value) {
+        value = value ?? !this.isLoadingLanguage();
+        this.isLoadingLanguage.set(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: LanguageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: LanguageService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: LanguageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * User levels constants.
+ */
+const USER_LEVELS = {
+    GUEST: 'guest',
+};
+
+var language = {
+	username: "user",
+	updateAPI: ""
+};
+var defaultConfigJSON = {
+	language: language
+};
+
+const DEFAULT_USERNAME = 'guest';
+const DEFAULT_LEVEL = 'guest';
+
+class UserService {
+    /**
+     * {@link IUserService.username}
+     */
+    username = signal(undefined, ...(ngDevMode ? [{ debugName: "username" }] : /* istanbul ignore next */ []));
+    /**
+     * {@link IUserService.token}
+     */
+    token = signal(undefined, ...(ngDevMode ? [{ debugName: "token" }] : /* istanbul ignore next */ []));
+    /**
+     * @see IUserService.locale
+     */
+    locale = signal(undefined, ...(ngDevMode ? [{ debugName: "locale" }] : /* istanbul ignore next */ []));
+    /**
+     * Derived signal that indicates whether the user is logged in.
+     * Returns true if both username and token are set and not empty.
+     */
+    isLoggedIn = computed(() => {
+        const username = this.username();
+        const token = this.token();
+        return (username !== null &&
+            username !== undefined &&
+            username !== STRING_EMPTY &&
+            token !== null &&
+            token !== undefined &&
+            token !== STRING_EMPTY);
+    }, ...(ngDevMode ? [{ debugName: "isLoggedIn" }] : /* istanbul ignore next */ []));
+    /**
+     * Constructor
+     * @constructor
+     * @ignore
+     */
+    constructor() {
+        this.initialize();
+    }
+    /**
+     * @see IUserService.setup$
+     */
+    setup$(setup) {
+        this.reset();
+        this.setUsername(setup.username);
+        return of(undefined);
+    }
+    /**
+     * @see IUserService.reset
+     */
+    reset() {
+        this.initialize();
+    }
+    /**
+     * @see IUserService.setUsername
+     */
+    setUsername(username) {
+        this.username.set(username);
+    }
+    /**
+     * @see IUserService.setLocale
+     */
+    setLocale(locale) {
+        this.locale.set(locale);
+    }
+    /**
+     * Initialization method
+     *
+     * @returns {void}
+     */
+    initialize() {
+        const config = defaultConfigJSON;
+        const setup = {
+            username: config.language?.username ?? DEFAULT_USERNAME,
+            level: DEFAULT_LEVEL,
+            api: {
+                patchUserDataAPIUrl: config.language?.updateAPI ?? STRING_EMPTY,
+            },
+        };
+        this.setup$(setup).pipe(take(1)).subscribe();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: UserService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: UserService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.4", ngImport: i0, type: UserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { APPLICATION_NAME };
+export { HttpService, LanguageService, TranslatePipe, TranslationsService, USER_LEVELS, UserService, authorizationInterceptor, logRequestInterceptor, requestTimestampInterceptor, unauthorizedInterceptor };
 //# sourceMappingURL=albi_scando-as-backbone-lib.mjs.map