@mosa-ng/core 17.0.0 → 19.0.0

package/fesm2022/mosa-ng-core.mjs

@@ -0,0 +1,1448 @@
+import * as i2 from '@angular/common';
+import { CommonModule, DatePipe } from '@angular/common';
+import * as i0 from '@angular/core';
+import { Injectable, Pipe, NgModule, provideAppInitializer, inject } from '@angular/core';
+import { firstValueFrom, of, BehaviorSubject, throwError, Observable, Subject } from 'rxjs';
+import { share, tap, catchError, map } from 'rxjs/operators';
+import * as i1$1 from '@angular/common/http';
+import { HttpErrorResponse, HttpResponse, HttpHeaders } from '@angular/common/http';
+import * as i1 from '@ngx-translate/core';
+
+/**
+ * Checks if an object is null or undefined. Does not check for
+ * empty strings, or false booleans
+ * @param val
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isNullOrUndefined(val) {
+    return val === null || val === undefined;
+}
+/**
+ * Checks if a string is null or empty
+ * @param str
+ */
+function isNullOrEmpty(str) {
+    return !str?.trim();
+}
+/**
+ * Checks if a string or number is zero or higher
+ * @param num
+ */
+function isZeroOrHigher(num) {
+    return num !== null && +num >= 0;
+}
+/**
+ * Checks if an object is a number
+ * @param num
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isNumber(num) {
+    return num !== null && !isNaN(+num);
+}
+/**
+ * Round to nearest number given
+ * @param value
+ * @param round
+ */
+function roundNearest(value) {
+    return Math.ceil(value / 5) * 5;
+}
+/**
+ * Merge a two dimensional array
+ * @param array
+ */
+function mergeArray(array) {
+    return array.reduce((flat, toFlatten) => flat.concat(Array.isArray(toFlatten) ? mergeArray(toFlatten) : toFlatten), []);
+}
+/**
+ * Get CSS Transform matrix from an element
+ * @param element
+ */
+function getTransformMatrix(element) {
+    const values = element.style.transform.split(/\w+\(|\);?/);
+    const transform = values[1].split(/,\s?/g).map((numStr) => parseInt(numStr, 10));
+    return {
+        x: transform[0],
+        y: transform[1],
+        z: transform[2],
+    };
+}
+/**
+ * Generates a random string with numbers and letters
+ * @param length
+ */
+function getRandomString(length = 10) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result;
+}
+/**
+ * Trys to convert a json string. If it fails it returns [null] or a given fallback of [T]
+ */
+function tryJsonParse(data, fallback) {
+    try {
+        if (!isNullOrEmpty(data)) {
+            return JSON.parse(data);
+        }
+    }
+    catch (err) {
+        // Ignore - go on with fallback check
+    }
+    if (fallback) {
+        return fallback();
+    }
+    return null;
+}
+
+var I18nSupported;
+(function (I18nSupported) {
+    I18nSupported["enUS"] = "en-US";
+    I18nSupported["deDE"] = "de-DE";
+    I18nSupported["deCH"] = "de-CH";
+    I18nSupported["deAT"] = "de-AT";
+    I18nSupported["enGB"] = "en-GB";
+    I18nSupported["frFR"] = "fr-FR";
+    I18nSupported["esES"] = "es-ES";
+    I18nSupported["ptPT"] = "pt-PT";
+})(I18nSupported || (I18nSupported = {}));
+
+const MOSA_MERGED_TRANSLATION = (lang) => `mosa_${lang}_merged_${location.host}`;
+const MOSA_FALLBACK_TRANSLATION = `mosa_${I18nSupported.enUS}_merged_${location.host}`;
+
+class TranslateCollectorService {
+    constructor(myTranslateService) {
+        this.myTranslateService = myTranslateService;
+        this.translationMap = {};
+    }
+    addTranslations(translation, lang, priority) {
+        if (isNullOrUndefined(this.translationMap[lang])) {
+            this.translationMap[lang] = [];
+        }
+        this.translationMap[lang].push({ priority, translation });
+        this.translationMap[lang].sort((a, b) => a.priority - b.priority);
+        const merged = JSON.parse(localStorage.getItem(MOSA_MERGED_TRANSLATION(lang))) || {};
+        for (const translationsData of this.translationMap[lang]) {
+            const translations = translationsData.translation;
+            if (translations != null) {
+                Object.keys(translations).forEach((key) => void (merged[key] = translations[key]));
+            }
+        }
+        let trans = true;
+        let count = 0;
+        while (trans) {
+            count++;
+            trans = false;
+            if (count >= 10) {
+                console.warn('Limit reached! Please check translation file! Last replaced values:');
+            }
+            Object.keys(merged).forEach((key) => {
+                if (merged[key].startsWith('@:')) {
+                    merged[key] = merged[merged[key].substring(2, merged[key].length)];
+                    trans = count < 10;
+                    if (count > 10) {
+                        console.warn(merged[key]);
+                    }
+                }
+            });
+        }
+        localStorage.setItem(MOSA_MERGED_TRANSLATION(lang), JSON.stringify(merged));
+        this.myTranslateService.reloadLang(lang);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: TranslateCollectorService, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: TranslateCollectorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: TranslateCollectorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }] });
+
+class AssetsI18nLoaderService {
+    constructor(myHttpClient, myTranslateCollectorService) {
+        this.myHttpClient = myHttpClient;
+        this.myTranslateCollectorService = myTranslateCollectorService;
+        this.priority = 0;
+    }
+    init(path, libName, priority) {
+        return new Promise(async (resolve) => {
+            if (this.supportedLanguages) {
+                for (let i = 0; i < this.supportedLanguages.length; i++) {
+                    await firstValueFrom(this.loadTranslations(this.supportedLanguages[i], path, libName, priority));
+                }
+                resolve();
+                return;
+            }
+            if (!this.subLanguages) {
+                this.subLanguages = this.myHttpClient.get(`assets/i18n/supported-languages.json?v=${getRandomString()}`)
+                    .pipe(share());
+            }
+            this.subLanguages.subscribe(async (res) => {
+                this.subLanguages = null;
+                this.supportedLanguages = res.languages;
+                for (let i = 0; i < this.supportedLanguages.length; i++) {
+                    await firstValueFrom(this.loadTranslations(this.supportedLanguages[i], path, libName, priority));
+                }
+                resolve();
+            }, () => {
+                this.subLanguages = null;
+                console.error('Missing file -> assets/i18n/supported-languages.json <-- FIX THIS!');
+                resolve();
+            });
+        });
+    }
+    loadTranslations(lang, path, libName, priority) {
+        const filename = libName ? `${libName}-${lang}.json` : `${lang}.json`;
+        return this.myHttpClient.get(`${(path || './assets/i18n/') + filename}?v=${getRandomString()}`)
+            .pipe(tap((response) => this.myTranslateCollectorService.addTranslations(response, lang, priority || this.priority)), catchError(() => {
+            console.error(`Missing file -> ${filename} <-- FIX THIS!`);
+            return of(null);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: AssetsI18nLoaderService, deps: [{ token: i1$1.HttpClient }, { token: TranslateCollectorService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: AssetsI18nLoaderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: AssetsI18nLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1$1.HttpClient }, { type: TranslateCollectorService }] });
+
+class CoreLoggerService {
+    /**
+     * Default constructor
+     */
+    constructor() {
+        this.uiLogs$ = new BehaviorSubject(null);
+    }
+    subUiLogs() {
+        return this.uiLogs$.asObservable();
+    }
+    /**
+     * Gets the error message from any type of object
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getErrorMsg(err) {
+        let msg = 'Unknown Error';
+        if (!err) {
+            return msg;
+        }
+        if (err instanceof HttpErrorResponse) {
+            if (typeof err.error !== 'string') {
+                return `mosa.commons.errors.status[${err.status}].message`;
+            }
+            return err.error;
+        }
+        if (typeof err === 'string') {
+            msg = err;
+        }
+        else if (err.msg) {
+            msg = err.msg;
+        }
+        else if (err.error?.msg) {
+            msg = err.error.msg;
+        }
+        else if (err.error?.message) {
+            msg = err.error.message;
+        }
+        else if (err.error?.errors && err.error?.errors[0]?.message) {
+            msg = err.error.errors[0].message;
+        }
+        else if (err.message) {
+            msg = err.message;
+        }
+        else if (err.Message) {
+            msg = err.Message;
+        }
+        if (typeof err.error === 'string') {
+            msg = err.error;
+        }
+        return msg;
+    }
+    /**
+     * Get the title to be shown in logger toast
+     * @param err
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getErrorTitle(err) {
+        let title = 'mosa.commons.logs.error.label';
+        if (err?.label) {
+            title = err.label;
+        }
+        else if (err?.title) {
+            title = err.title;
+        }
+        else if (err?.error?.label) {
+            title = err.error.label;
+        }
+        else if (err?.error?.title) {
+            title = err.error.title;
+        }
+        return title;
+    }
+    /**
+     * Logs an error to the user
+     * @param data
+     * @param showUser
+     * @param config
+     */
+    logError(config) {
+        config = this.serializeConfig(config);
+        config.msg = this.getErrorMsg(config.msg);
+        if (!config.title) {
+            config.title = this.getErrorTitle(config.msg);
+        }
+        config.className = 'snackbar-error';
+        this.show(config, 'error');
+    }
+    /**
+     * Logs a success message to the user
+     * @param data
+     * @param config
+     */
+    logSuccess(config) {
+        config = this.serializeConfig(config);
+        config.className = 'snackbar-success';
+        this.show(config, 'success');
+    }
+    /**
+     * Logs a warning to the user
+     * @param data
+     * @param showUser
+     * @param config
+     */
+    logWarning(config) {
+        config = this.serializeConfig(config);
+        config.className = 'snackbar-warning';
+        this.show(config, 'warning');
+    }
+    /**
+     * Logs an info to the user
+     * @param data
+     * @param config
+     */
+    logInfo(config) {
+        config = this.serializeConfig(config);
+        config.className = 'snackbar-info';
+        this.show(config, 'info');
+    }
+    /**
+     * Logs any kind of message to the user
+     * @param data
+     * @param config
+     */
+    log(config) {
+        config = this.serializeConfig(config);
+        config.className = 'snackbar-default';
+        this.show(config, 'default');
+    }
+    /**
+     * Show the log
+     * @requires @mosa-ng/material
+     * @param data
+     * @param type
+     * @param config
+     */
+    show(config, type) {
+        this.uiLogs$.next({ title: config.title, msg: config.msg, type, config });
+    }
+    /**
+     * Serializes empty values, so no error is being returned
+     * @param config
+     * @private
+     */
+    serializeConfig(config) {
+        // Check if user has default config
+        if (!this.defaultConfig) {
+            this.defaultConfig = {
+                debug: true,
+            };
+        }
+        if (!config) {
+            // Get user default config
+            config = {
+                showDismiss: this.defaultConfig.showDismiss,
+                closeOnClick: isNullOrUndefined(this.defaultConfig.closeOnClick) ? true : this.defaultConfig.closeOnClick,
+                className: this.defaultConfig.className,
+                duration: this.defaultConfig.duration || 4,
+            };
+        }
+        // Serialize configuration
+        config.duration = CoreLoggerService.getValue(config.duration, this.defaultConfig.duration, 4);
+        config.className = CoreLoggerService.getValue(config.className, this.defaultConfig.className, null);
+        config.showDismiss = CoreLoggerService.getValue(config.showDismiss, this.defaultConfig.showDismiss, false);
+        config.closeOnClick = CoreLoggerService.getValue(config.closeOnClick, this.defaultConfig.closeOnClick, true);
+        return config;
+    }
+    /**
+     * Gets a value which is not undefined or null
+     * @param val
+     * @param val1
+     * @param def
+     * @private
+     */
+    static getValue(val, val1, def) {
+        if (isNullOrUndefined(val)) {
+            if (isNullOrUndefined(val1)) {
+                return def;
+            }
+            return val1;
+        }
+        return val;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: CoreLoggerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: CoreLoggerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: CoreLoggerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+const LOCAL_STORAGE_TOKEN_KEY = 'tokenSettings';
+class ApiService {
+    constructor(myCoreLoggerService, myHttpClient) {
+        this.myCoreLoggerService = myCoreLoggerService;
+        this.myHttpClient = myHttpClient;
+    }
+    /**
+     * Gets an access token
+     * @deprecated use getToken()
+     */
+    getAccessToken() {
+        return window.localStorage.getItem('jwtAccessToken');
+    }
+    /**
+     * Sets an access token
+     * @param token
+     * @deprecated use setToken()
+     */
+    setAccessToken(token) {
+        window.localStorage.setItem('jwtAccessToken', token);
+    }
+    /**
+     * Removes an access token from local storage
+     * @deprecated use deleteAccessToken()
+     */
+    removeAccessToken() {
+        window.localStorage.removeItem('jwtAccessToken');
+    }
+    /**
+     * Sets the token
+     * @param tokenSettings
+     */
+    setToken(tokenSettings) {
+        window.localStorage.setItem(LOCAL_STORAGE_TOKEN_KEY, JSON.stringify(tokenSettings));
+    }
+    /**
+     * Gets token
+     */
+    getToken() {
+        const tokenSettings = window.localStorage.getItem(LOCAL_STORAGE_TOKEN_KEY);
+        if (isNullOrEmpty(tokenSettings)) {
+            return null;
+        }
+        return JSON.parse(tokenSettings);
+    }
+    /**
+     * Deletes token
+     */
+    deleteToken() {
+        window.localStorage.removeItem(LOCAL_STORAGE_TOKEN_KEY);
+    }
+    /**
+     * Makes an http get call
+     * @param url
+     * @param headers
+     * @param options
+     */
+    get(url, headers, options) {
+        options = ApiService.serializeOptions(options);
+        headers = this.getHeaders(headers, options);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this.myHttpClient.get(url, { ...options.httpOptions, headers })
+            .pipe(map((response) => this.handleResponse(response)), catchError((err) => this.handleError(err, options)));
+    }
+    /**
+     * Makes an async http get call, which also includes the response headers
+     * @param url
+     * @param headers
+     * @param options
+     */
+    async getWithHeadersAsync(url, headers, options) {
+        return this.getWithHeaders(url, headers, options).toPromise();
+    }
+    /**
+     * Makes an http get call, which also includes the response headers
+     * @param url
+     * @param headers
+     * @param options
+     */
+    getWithHeaders(url, headers, options) {
+        options = ApiService.serializeOptions(options);
+        headers = this.getHeaders(headers, options);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this.myHttpClient.get(url, { ...options.httpOptions, headers, observe: 'response' })
+            .pipe(catchError((err) => this.handleError(err, options)));
+    }
+    /**
+     * Makes an http patch call (For partial updates)
+     * @param url
+     * @param data
+     * @param headers
+     * @param options
+     */
+    patch(url, data, headers, options) {
+        options = ApiService.serializeOptions(options);
+        headers = this.getHeaders(headers, options);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this.myHttpClient.patch(url, data, { ...options.httpOptions, headers })
+            .pipe(map((response) => this.handleResponse(response)), catchError((err) => this.handleError(err, options)));
+    }
+    /**
+     * Makes an http put call
+     * @param url
+     * @param data
+     * @param headers
+     * @param options
+     */
+    put(url, data, headers, options) {
+        options = ApiService.serializeOptions(options);
+        headers = this.getHeaders(headers, options);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this.myHttpClient.put(url, data, { ...options.httpOptions, headers })
+            .pipe(map((response) => this.handleResponse(response)), catchError((err) => this.handleError(err, options)));
+    }
+    /**
+     * Makes an http post call
+     * @param url
+     * @param data
+     * @param headers
+     * @param options
+     */
+    post(url, data, headers, options) {
+        options = ApiService.serializeOptions(options);
+        headers = this.getHeaders(headers, options);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this.myHttpClient.post(url, data, { ...options.httpOptions, headers })
+            .pipe(map((response) => this.handleResponse(response)), catchError((err) => this.handleError(err, options)));
+    }
+    /**
+     * makes an http delete call
+     * @param url
+     * @param headers
+     * @param options
+     * @returns Observable
+     */
+    delete(url, headers, options) {
+        options = ApiService.serializeOptions(options);
+        headers = this.getHeaders(headers, options);
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        return this.myHttpClient.delete(url, { ...options.httpOptions, headers })
+            .pipe(catchError((err) => this.handleError(err, options)));
+    }
+    /**
+     * Appends a script to the html body
+     * @param path
+     * @param attributes
+     * @param onLoad
+     */
+    loadExternalScript(path, attributes, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    onLoad) {
+        const script = document.createElement('script');
+        script.type = 'text/javascript';
+        script.src = path;
+        script.async = true;
+        if (onLoad) {
+            script.onload = onLoad;
+        }
+        if (attributes) {
+            for (const attribute of attributes) {
+                script.setAttribute(attribute.key, attribute.value);
+            }
+        }
+        document.body.append(script);
+    }
+    handleError(err, options) {
+        if (!options?.skipErrorHandling) {
+            this.myCoreLoggerService.logError({ msg: err });
+        }
+        return throwError(err);
+    }
+    handleResponse(response) {
+        if (response instanceof HttpResponse) {
+            return response.body;
+        }
+        return response;
+    }
+    getHeaders(headers, options) {
+        if (!headers) {
+            headers = new HttpHeaders();
+        }
+        if (!options.skipContentType) {
+            if (!headers.get('Content-Type')) {
+                headers = headers.set('Content-Type', 'application/json');
+            }
+        }
+        if (!options?.skipAuth) {
+            if (this.getToken()) {
+                const tokenSettings = this.getToken();
+                headers = headers.set('Authorization', `${tokenSettings.tokenType} ${tokenSettings.token}`);
+            }
+            else {
+                // Deprecated. Use ITokenSettings
+                headers = headers.set('Authorization', `Bearer ${this.getAccessToken()}`);
+            }
+        }
+        return headers;
+    }
+    static serializeOptions(options) {
+        if (!options) {
+            options = {};
+        }
+        if (!options.httpOptions) {
+            options.httpOptions = {};
+        }
+        return options;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ApiService, deps: [{ token: CoreLoggerService }, { token: i1$1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ApiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: CoreLoggerService }, { type: i1$1.HttpClient }] });
+
+class MosaSocketService {
+    constructor() {
+    }
+    connect(url) {
+        if (!this.subject) {
+            this.subject = this.create(url);
+        }
+        return this.subject;
+    }
+    send(data) {
+        this.subject.next(data);
+    }
+    create(url) {
+        const ws = new WebSocket(url);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const observable = new Observable((obs) => {
+            ws.onmessage = obs.next.bind(obs);
+            ws.onerror = obs.error.bind(obs);
+            ws.onclose = obs.complete.bind(obs);
+            return ws.close.bind(ws);
+        });
+        const observer = {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            next: (data) => {
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify(data));
+                }
+            },
+        };
+        return Subject.create(observer, observable);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MosaSocketService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MosaSocketService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MosaSocketService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+class CustomTranslateLoaderService {
+    getTranslation(lang) {
+        return new Observable((observer) => {
+            const item = localStorage.getItem(MOSA_MERGED_TRANSLATION(lang));
+            const responseObj = tryJsonParse(item, () => this.loadFallbackLanguage());
+            observer.next(responseObj);
+            observer.complete();
+        });
+    }
+    loadFallbackLanguage() {
+        const defaultTranslation = localStorage.getItem(MOSA_FALLBACK_TRANSLATION);
+        return isNullOrEmpty(defaultTranslation) ? {} : JSON.parse(defaultTranslation);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: CustomTranslateLoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: CustomTranslateLoaderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: CustomTranslateLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class CanDeactivateGuard {
+    canDeactivate(component) {
+        return component.canDeactivate ? component.canDeactivate() : true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: CanDeactivateGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: CanDeactivateGuard, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: CanDeactivateGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class Dictionary {
+    /**
+     * Default constructor.
+     * @param data Requires an array of IDictionaryItem with a key and a value
+     */
+    constructor(...data) {
+        this.dictionaryItems$ = new BehaviorSubject(data);
+    }
+    /**
+     * Observable to subscribe to dictionary changes
+     */
+    valueChanges() {
+        return this.dictionaryItems$.asObservable();
+    }
+    /**
+     * Observable to subscribe to dictionary as object changes
+     */
+    objectArray() {
+        return this.dictionaryItems$.asObservable()
+            .pipe(map((items) => this.toObject(items)));
+    }
+    /**
+     * Gets the items of the dictionary
+     * @returns dictionary items
+     */
+    get items() {
+        return this.dictionaryItems$.value;
+    }
+    /**
+     * Gets a dictionary item by key
+     * @param key
+     * @returns single dictionary item
+     */
+    get(key) {
+        return this.dictionaryItems$.value.find((item) => item.key === key);
+    }
+    /**
+     * Checks if dictionary contains item
+     * @param key
+     */
+    contains(key) {
+        return this.get(key) != null;
+    }
+    /**
+     * Adds a dictionary item
+     * @param key
+     * @param value
+     */
+    add(key, value) {
+        const dictionaryItems = [...this.dictionaryItems$.value];
+        dictionaryItems.push({ key, value });
+        this.updateItems(dictionaryItems);
+    }
+    /**
+     * Updates a dictionary item
+     * @param data
+     * @param index
+     */
+    update(data, index) {
+        const dictionaryItems = [...this.dictionaryItems$.value];
+        if (!index) {
+            index = this.getIndex(data.key);
+        }
+        if (index !== -1) {
+            dictionaryItems[index] = data;
+        }
+        else {
+            console.warn('Dictionary: Index not found');
+        }
+        this.updateItems(dictionaryItems);
+    }
+    /**
+     * Gets an index with a specific key
+     * @param key
+     */
+    getIndex(key) {
+        return this.dictionaryItems$.value.findIndex((val) => val.key === key);
+    }
+    /**
+     * Removes an item from the dictionary
+     * @param value
+     * @param index
+     */
+    remove(value, index) {
+        const dictionaryItems = [...this.dictionaryItems$.value];
+        if (!index) {
+            index = this.getIndex(value);
+        }
+        if (index !== -1) {
+            dictionaryItems.splice(index, 1);
+        }
+        else {
+            console.warn('Dictionary: Index not found');
+        }
+        this.updateItems(dictionaryItems);
+    }
+    /**
+     * Private function to cast array to an object
+     * @param items
+     * @private
+     */
+    toObject(items) {
+        const obj = {};
+        for (const item of items) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            obj[item.key] = item.value;
+        }
+        return obj;
+    }
+    /**
+     * Private function to update dictionary items
+     * @param items
+     * @private
+     */
+    updateItems(items) {
+        this.dictionaryItems$.next(items);
+    }
+}
+
+/* eslint-disable @typescript-eslint/unbound-method */
+/**
+ * Cast any type
+ * @param data to be casted
+ * @returns casted data
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any,max-classes-per-file
+function cast(data) {
+    return data;
+}
+class StringExtensions {
+    getPart(maxChars, appendDot) {
+        let newStr = cast(this).replace(/\\n/g, ' ');
+        if (newStr.length > maxChars) {
+            newStr = newStr.substring(0, maxChars);
+            if (appendDot && newStr.length > maxChars - 3) {
+                newStr += '...';
+            }
+        }
+        return newStr;
+    }
+    fromJSON() {
+        let str = cast(this);
+        if (typeof this !== 'string') {
+            str = JSON.stringify(str);
+        }
+        try {
+            str = JSON.parse(str);
+        }
+        catch (e) {
+            return null;
+        }
+        if (typeof str === 'object') {
+            return str;
+        }
+        return null;
+    }
+    toCSSClass() {
+        return cast(this)?.replace(/([a-z])([A-Z])/, '$1-$2').toLowerCase();
+    }
+    toUTC() {
+        return `${cast(this)}Z`;
+    }
+}
+class ArrayExtensions {
+    hasChanges(data) {
+        return JSON.stringify(this) !== JSON.stringify(data);
+    }
+    replaceRange(data, start, end) {
+        const array = cast(this);
+        let replaceDataIndex = 0;
+        for (let i = start; i < end; i++) {
+            if (!array[i] && !data[replaceDataIndex]) {
+                array.splice(i, 1);
+                continue;
+            }
+            array[i] = data[replaceDataIndex];
+            replaceDataIndex++;
+        }
+        return array;
+    }
+}
+class NumberExtensions {
+    between(start, end) {
+        const num = cast(this);
+        return num >= start && num <= end;
+    }
+}
+class Prototypes {
+    /**
+     * Initialize prototypes
+     */
+    static init() {
+        const stringExtensions = new StringExtensions();
+        const arrayExtensions = new ArrayExtensions();
+        const numberExtensions = new NumberExtensions();
+        String.prototype.getPart = stringExtensions.getPart;
+        String.prototype.fromJSON = stringExtensions.fromJSON;
+        String.prototype.toCSSClass = stringExtensions.toCSSClass;
+        String.prototype.toUTC = stringExtensions.toUTC;
+        Array.prototype.hasChanges = arrayExtensions.hasChanges;
+        Array.prototype.replaceRange = arrayExtensions.replaceRange;
+        Number.prototype.between = numberExtensions.between;
+    }
+}
+
+class Sieve {
+    constructor(options) {
+        this.options = options;
+        this.options.baseUrl = options.baseUrl || '';
+        this.options.filters = options.filters || [];
+        this.options.sorts = options.sorts || [];
+    }
+    /**
+     * public getter to get page size
+     */
+    get pageSize() {
+        return this.options.pageSize;
+    }
+    /**
+     * Setter to set page size
+     */
+    set pageSize(pageSize) {
+        this.options.pageSize = pageSize;
+    }
+    /**
+     * public getter to get page
+     */
+    get page() {
+        return this.options.page;
+    }
+    /**
+     * Setter to set page
+     */
+    set page(page) {
+        this.options.page = page;
+    }
+    /**
+     * public getter to get filters
+     */
+    get filters() {
+        return this.options.filters;
+    }
+    /**
+     * Setter to set filters
+     */
+    set filters(filters) {
+        this.options.filters = filters;
+    }
+    /**
+     * public getter to get sorts
+     */
+    get sorts() {
+        return this.options.sorts;
+    }
+    /**
+     * Setter to set sorts
+     */
+    set sorts(sorts) {
+        this.options.sorts = sorts;
+    }
+    /**
+     * method to add a sort option
+     * @param name of the item to sort
+     * @param desc sort descending
+     */
+    addSort(name, desc) {
+        this.options.sorts.push({
+            name,
+            desc,
+        });
+    }
+    /**
+     * method to add a filter option
+     * @param key of the item
+     * @param operator { SieveOperator }
+     * @param value filtered value
+     */
+    addFilter(key, operator, value) {
+        this.options.filters.push({
+            key,
+            operator,
+            value,
+        });
+    }
+    /**
+     * Getter for base url
+     */
+    get baseUrl() {
+        return this.options.baseUrl;
+    }
+    /**
+     * Setter for base url
+     * @param url
+     */
+    set baseUrl(url) {
+        this.options.baseUrl = url;
+    }
+    /**
+     * Convert to queried string
+     */
+    getUrl() {
+        return `${this.options.baseUrl}${this.toQuery()}`;
+    }
+    /**
+     * to Query
+     * @private converts options to actual query
+     */
+    toQuery() {
+        let query = '?';
+        if (this.page) {
+            query += `page=${this.page}`;
+        }
+        if (this.pageSize) {
+            query += `&pageSize=${this.pageSize}`;
+        }
+        if (this.filters?.length) {
+            let filterQuery = '&filters=';
+            for (const filter of this.filters) {
+                if (filter.value) {
+                    filterQuery += `${filter.key}${filter.operator}${filter.value},`;
+                }
+            }
+            if (filterQuery !== '&filters=') {
+                filterQuery = filterQuery.slice(0, -1);
+                query += filterQuery;
+            }
+        }
+        if (this.sorts?.length) {
+            let sortQuery = '&sorts=';
+            for (const sort of this.sorts) {
+                sortQuery += `${sort.desc ? '-' : '+'}${sort.name},`;
+            }
+            sortQuery = sortQuery.slice(0, -1);
+            query += sortQuery;
+        }
+        if (query.startsWith('&')) {
+            query = query.slice(1);
+        }
+        return query;
+    }
+}
+
+var Theme;
+(function (Theme) {
+    Theme[Theme["light"] = 0] = "light";
+    Theme[Theme["dark"] = 1] = "dark";
+})(Theme || (Theme = {}));
+
+var ContentPosition;
+(function (ContentPosition) {
+    ContentPosition["top"] = "top";
+    ContentPosition["topLeft"] = "top-left";
+    ContentPosition["topRight"] = "top-right";
+    ContentPosition["bottom"] = "bottom";
+    ContentPosition["bottomLeft"] = "bottom-left";
+    ContentPosition["bottomRight"] = "bottom-right";
+    ContentPosition["center"] = "center";
+    ContentPosition["centerLeft"] = "center-left";
+    ContentPosition["centerRight"] = "center-right";
+})(ContentPosition || (ContentPosition = {}));
+
+var Browser;
+(function (Browser) {
+    Browser[Browser["chrome"] = 0] = "chrome";
+    Browser[Browser["firefox"] = 1] = "firefox";
+    Browser[Browser["internetExplorer"] = 2] = "internetExplorer";
+    Browser[Browser["opera"] = 3] = "opera";
+    Browser[Browser["edge"] = 4] = "edge";
+    Browser[Browser["safari"] = 5] = "safari";
+    Browser[Browser["other"] = 6] = "other";
+})(Browser || (Browser = {}));
+
+class MosaDatePipe {
+    constructor(myTranslateService, myDatePipe) {
+        this.myTranslateService = myTranslateService;
+        this.myDatePipe = myDatePipe;
+        this.store$ = new BehaviorSubject(null);
+        this.updateTemplates();
+        setInterval(() => {
+            this.store$.next(new Date().getTime());
+        }, 10);
+        this.myTranslateService.onLangChange.subscribe(() => {
+            this.updateTemplates();
+            this.store$.next(new Date().getTime());
+        });
+    }
+    transform(date, mode = 'timeSince') {
+        return this.store$.pipe(map((currentDate) => this.calcDate(currentDate, date, mode)));
+    }
+    calcDate(currentDate, date, mode) {
+        let parsed;
+        if (date instanceof Date) {
+            parsed = new Date(date.toString()).getTime();
+        }
+        else {
+            parsed = new Date(date).getTime();
+        }
+        if (!currentDate) {
+            currentDate = new Date().getTime();
+        }
+        const convertedDate = this.myDatePipe.transform(parsed, 'dd. MMM. yyyy hh:mm aaa');
+        if (mode === 'full' || mode === 'timeSince') {
+            const seconds = ((currentDate - parsed) * .001) >> 0;
+            const minutes = seconds / 60;
+            const hours = minutes / 60;
+            const days = hours / 24;
+            const years = days / 365;
+            const timeSince = this.templates['prefix'] + (seconds < 60 && this.template('seconds', seconds) ||
+                seconds < 120 && this.template('minute', 1) ||
+                minutes < 60 && this.template('minutes', minutes) ||
+                minutes < 120 && this.template('hour', 1) ||
+                hours < 24 && this.template('hours', hours) ||
+                hours < 42 && this.template('day', 1) ||
+                days < 30 && this.template('days', days) ||
+                days < 45 && this.template('month', 1) ||
+                days < 365 && this.template('months', days / 30) ||
+                years < 1.5 && this.template('year', 1) ||
+                this.template('years', years)) + this.templates['prefix'];
+            if (mode === 'timeSince') {
+                return timeSince;
+            }
+            if (mode === 'full') {
+                return `${convertedDate} (${timeSince})`;
+            }
+        }
+        return convertedDate;
+    }
+    template(key, val) {
+        return this.templates[key] && this.templates[key].replace(/%d/i, String(Math.abs(Math.round(val))));
+    }
+    updateTemplates() {
+        this.templates = {
+            prefix: this.myTranslateService.instant('mosa.pipes.timeSince.prefix'),
+            suffix: this.myTranslateService.instant('mosa.pipes.timeSince.suffix'),
+            seconds: this.myTranslateService.instant('mosa.pipes.timeSince.seconds'),
+            minute: this.myTranslateService.instant('mosa.pipes.timeSince.minute'),
+            minutes: this.myTranslateService.instant('mosa.pipes.timeSince.minutes'),
+            hour: this.myTranslateService.instant('mosa.pipes.timeSince.hour'),
+            hours: this.myTranslateService.instant('mosa.pipes.timeSince.hours'),
+            day: this.myTranslateService.instant('mosa.pipes.timeSince.day'),
+            days: this.myTranslateService.instant('mosa.pipes.timeSince.days'),
+            month: this.myTranslateService.instant('mosa.pipes.timeSince.month'),
+            months: this.myTranslateService.instant('mosa.pipes.timeSince.months'),
+            year: this.myTranslateService.instant('mosa.pipes.timeSince.year'),
+            years: this.myTranslateService.instant('mosa.pipes.timeSince.years'),
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MosaDatePipe, deps: [{ token: i1.TranslateService }, { token: i2.DatePipe }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: MosaDatePipe, isStandalone: false, name: "mosaDate" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MosaDatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'mosaDate',
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }, { type: i2.DatePipe }] });
+
+class MosaDatePipeModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MosaDatePipeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: MosaDatePipeModule, declarations: [MosaDatePipe], imports: [CommonModule], exports: [MosaDatePipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MosaDatePipeModule, providers: [DatePipe], imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MosaDatePipeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [MosaDatePipe],
+                    imports: [
+                        CommonModule,
+                    ],
+                    exports: [MosaDatePipe],
+                    providers: [DatePipe],
+                }]
+        }] });
+
+class DictionaryItemPipe {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transform(key, dictionary) {
+        return dictionary.get(key)?.value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DictionaryItemPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: DictionaryItemPipe, isStandalone: false, name: "dictionaryItem" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DictionaryItemPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'dictionaryItem',
+                    standalone: false,
+                }]
+        }] });
+
+class DictionaryItemPipeModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DictionaryItemPipeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: DictionaryItemPipeModule, declarations: [DictionaryItemPipe], imports: [CommonModule], exports: [DictionaryItemPipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DictionaryItemPipeModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DictionaryItemPipeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [DictionaryItemPipe],
+                    imports: [
+                        CommonModule,
+                    ],
+                    exports: [
+                        DictionaryItemPipe,
+                    ],
+                }]
+        }] });
+
+class MosaDurationPipe {
+    constructor(myTranslateService) {
+        this.myTranslateService = myTranslateService;
+        this.store$ = new BehaviorSubject(new Date().getTime());
+        this.interval = setInterval(() => {
+            this.store$.next(new Date().getTime());
+        }, 1000);
+        this.myTranslateService.onLangChange.subscribe(() => {
+            this.store$.next(new Date().getTime());
+        });
+    }
+    /**
+     * Converts a timestamp to a duration in the given format
+     * @param millis
+     * @param format
+     * @returns
+     * auto: 15000 -> 15 seconds
+     * seconds: 15000 -> 15 seconds
+     * minutes: 60000 -> 1 minute
+     * hours: 7200000 -> 2 hours
+     * days: 172800000 -> 2 days
+     */
+    transform(millis, format = 'auto') {
+        return this.store$.pipe(map((currentDate) => {
+            if (!millis) {
+                clearInterval(this.interval);
+                return null;
+            }
+            if (millis - currentDate < 0) {
+                clearInterval(this.interval);
+                return null;
+            }
+            return this.calcDuration(currentDate, millis, format);
+        }));
+    }
+    getTranslation(num, format) {
+        if (num === 1) {
+            return `${num.toFixed(0)} ${this.myTranslateService.instant(`mosa.commons.dateTime[${format}].label`)}`;
+        }
+        return `${num.toFixed(0)} ${this.myTranslateService.instant(`mosa.commons.dateTime[${format}].plural.label`)}`;
+    }
+    calcDuration(currentDate, millis, format) {
+        millis = millis - currentDate;
+        const seconds = millis / 1000;
+        if (format === 'seconds') {
+            return this.getTranslation(seconds, 'seconds');
+        }
+        const minutes = seconds / 60;
+        if (format === 'minutes') {
+            return this.getTranslation(minutes, 'minutes');
+        }
+        const hours = minutes / 60;
+        if (format === 'hours') {
+            return this.getTranslation(hours, 'hours');
+        }
+        const days = hours / 24;
+        if (format === 'days') {
+            return this.getTranslation(days, 'days');
+        }
+        if (format === 'auto') {
+            if (seconds < 60) {
+                return this.getTranslation(seconds, 'seconds');
+            }
+            if (minutes < 60) {
+                return this.getTranslation(minutes, 'minutes');
+            }
+            if (hours < 24) {
+                return this.getTranslation(hours, 'hours');
+            }
+            return this.getTranslation(days, 'days');
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MosaDurationPipe, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: MosaDurationPipe, isStandalone: false, name: "mosaDuration" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MosaDurationPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'mosaDuration',
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }] });
+
+class MosaDurationPipeModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MosaDurationPipeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: MosaDurationPipeModule, declarations: [MosaDurationPipe], imports: [CommonModule], exports: [MosaDurationPipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MosaDurationPipeModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MosaDurationPipeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [MosaDurationPipe],
+                    imports: [
+                        CommonModule,
+                    ],
+                    exports: [MosaDurationPipe],
+                }]
+        }] });
+
+class FindInArrayPipe {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transform(searchValue, array, searchKey, returnElements) {
+        // Return if array is empty or null
+        if (!array || !array.length) {
+            return null;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const foundItem = array.find((val) => (searchKey ? val[searchKey] : val) === searchValue);
+        if (!foundItem) {
+            return null;
+        }
+        // Return whole item
+        if (!returnElements) {
+            return foundItem;
+        }
+        if (returnElements.length === 1) {
+            return foundItem[returnElements[0]];
+        }
+        // Return given values to the keys
+        return returnElements.map((val) => foundItem[val]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: FindInArrayPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: FindInArrayPipe, isStandalone: false, name: "findInArray" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: FindInArrayPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'findInArray',
+                    standalone: false,
+                }]
+        }] });
+
+class FindInArrayPipeModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: FindInArrayPipeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: FindInArrayPipeModule, declarations: [FindInArrayPipe], imports: [CommonModule], exports: [FindInArrayPipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: FindInArrayPipeModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: FindInArrayPipeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        FindInArrayPipe,
+                    ],
+                    imports: [
+                        CommonModule,
+                    ],
+                    exports: [
+                        FindInArrayPipe,
+                    ],
+                }]
+        }] });
+
+class JoinPipe {
+    /**
+     * Join array by separator
+     * @param array
+     * @param returnField
+     * @param separator
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transform(array, returnField, separator = ', ') {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return array.map((val) => returnField ? val[returnField] : val).join(separator);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: JoinPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: JoinPipe, isStandalone: false, name: "join" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: JoinPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'join',
+                    standalone: false,
+                }]
+        }] });
+
+class JoinPipeModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: JoinPipeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: JoinPipeModule, declarations: [JoinPipe], imports: [CommonModule], exports: [JoinPipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: JoinPipeModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: JoinPipeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        JoinPipe,
+                    ],
+                    exports: [
+                        JoinPipe,
+                    ],
+                    imports: [
+                        CommonModule,
+                    ],
+                }]
+        }] });
+
+function initI18n(i18n) {
+    return () => i18n.init(null, null, 1);
+}
+function initI18nCore(i18n) {
+    return () => i18n.init(null, 'mosa');
+}
+class MosaCoreModule {
+    static forRoot() {
+        return {
+            ngModule: MosaCoreModule,
+            providers: [
+                provideAppInitializer(() => {
+                    const initializerFn = (initI18n)(inject(AssetsI18nLoaderService));
+                    return initializerFn();
+                }),
+                provideAppInitializer(() => {
+                    const initializerFn = (initI18nCore)(inject(AssetsI18nLoaderService));
+                    return initializerFn();
+                }),
+            ],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MosaCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: MosaCoreModule, imports: [CommonModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MosaCoreModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MosaCoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [
+                        CommonModule,
+                    ],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ApiService, ArrayExtensions, AssetsI18nLoaderService, Browser, CanDeactivateGuard, ContentPosition, CoreLoggerService, CustomTranslateLoaderService, Dictionary, DictionaryItemPipe, DictionaryItemPipeModule, FindInArrayPipe, FindInArrayPipeModule, I18nSupported, JoinPipe, JoinPipeModule, LOCAL_STORAGE_TOKEN_KEY, MOSA_FALLBACK_TRANSLATION, MOSA_MERGED_TRANSLATION, MosaCoreModule, MosaDatePipe, MosaDatePipeModule, MosaDurationPipe, MosaDurationPipeModule, MosaSocketService, NumberExtensions, Prototypes, Sieve, StringExtensions, Theme, TranslateCollectorService, cast, getRandomString, getTransformMatrix, initI18n, initI18nCore, isNullOrEmpty, isNullOrUndefined, isNumber, isZeroOrHigher, mergeArray, roundNearest, tryJsonParse };
+//# sourceMappingURL=mosa-ng-core.mjs.map