@stemy/ngx-utils 12.1.3 → 13.0.0

package/esm2020/ngx-utils/services/config.service.mjs

@@ -0,0 +1,130 @@
+import { Inject, Injectable, Optional, isDevMode } from "@angular/core";
+import { HttpClient } from "@angular/common/http";
+import { UniversalService } from "./universal.service";
+import { BASE_CONFIG, IConfiguration, ROOT_ELEMENT, SCRIPT_PARAMS } from "../common-types";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./universal.service";
+import * as i3 from "../common-types";
+const JSON5 = require("json5");
+export class ConfigService {
+    constructor(http, universal, rootElement, baseConfig = null, scriptParams = null) {
+        this.http = http;
+        this.universal = universal;
+        this.rootElement = rootElement;
+        for (const key in []) {
+            Object.defineProperty(Array.prototype, key, {
+                enumerable: false
+            });
+        }
+        let baseUrl = "";
+        if (this.universal.isBrowser) {
+            const currentScript = document.currentScript;
+            if (!!currentScript) {
+                const scriptSrc = currentScript.src;
+                const srcParts = scriptSrc.split(".js");
+                baseUrl = scriptSrc.substr(0, srcParts[0].lastIndexOf("/") + 1);
+            }
+        }
+        this.baseConfig = baseConfig || {};
+        this.loadedConfig = Object.assign(!baseUrl ? {} : { baseUrl, baseDomain: this.parseDomain(baseUrl) }, this.baseConfig);
+        this.scriptParameters = scriptParams || {};
+        this.loaderFunc = () => {
+            this.loader = this.loader || new Promise((resolve, reject) => {
+                this.loadJson().then(config => {
+                    this.loadedConfig = config = Object.assign(this.loadedConfig, config);
+                    this.prepareConfig(config).then(c => {
+                        this.loadedConfig = c;
+                        c.baseUrl = c.baseUrl || "/";
+                        resolve(c);
+                    });
+                }, reject);
+            });
+            return this.loader;
+        };
+        this.initService();
+    }
+    get load() {
+        return this.loaderFunc;
+    }
+    get config() {
+        return this.loadedConfig;
+    }
+    get configUrl() {
+        return `${this.loadedConfig.baseUrl}config/config.json`;
+    }
+    parseDomain(baseUrl) {
+        try {
+            const url = new URL(baseUrl);
+            const port = url.port && url.port !== "443" && url.port !== "80" ? `:${url.port}` : ``;
+            return `${url.protocol}//${url.hostname}${port}/`;
+        }
+        catch {
+            return "/";
+        }
+    }
+    initService() {
+    }
+    async loadJson() {
+        if (this.universal.isServer) {
+            return Promise.resolve(this.loadedConfig);
+        }
+        const configUrl = this.configUrl;
+        try {
+            const config5 = await this.http.get(isDevMode() ? `${configUrl}5` : configUrl, { responseType: "text" }).toPromise();
+            return JSON5.parse(config5);
+        }
+        catch (e) {
+            try {
+                const config = await this.http.get(configUrl).toPromise();
+                console.log(`Can't parse json5 config: ${e}`);
+                return config;
+            }
+            catch (e) {
+                throw new Error(`Config file not found at: ${configUrl}`);
+            }
+        }
+    }
+    prepareConfig(config) {
+        return Promise.resolve(config);
+    }
+    prepareUrl(url, ending) {
+        const project = !this.loadedConfig ? "" : this.loadedConfig.project;
+        const needsProtocol = url?.startsWith("//") ?? false;
+        url = !needsProtocol && url?.startsWith("/") ? this.loadedConfig.baseDomain + url.substr(1) : url || "";
+        url = `${url.replace(/\/+$/, "")}${ending}`.replace("[project]", project);
+        return this.universal.isServer && needsProtocol ? `http:${url}` : url;
+    }
+    getConfigValue(key) {
+        return this.loadedConfig[key];
+    }
+    getQueryParameter(name, url) {
+        url = url || (this.universal.isBrowser ? window.location.href : "");
+        name = name.replace(/[\[\]]/g, "\\$&");
+        const regex = new RegExp("[?&]" + name + "(=([^&#]*)|&|#|$)"), results = regex.exec(url);
+        if (!results)
+            return null;
+        if (!results[2])
+            return "";
+        return decodeURIComponent(results[2].replace(/\+/g, " "));
+    }
+}
+ConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ConfigService, deps: [{ token: i1.HttpClient }, { token: i2.UniversalService }, { token: ROOT_ELEMENT }, { token: BASE_CONFIG, optional: true }, { token: SCRIPT_PARAMS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ConfigService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ConfigService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.UniversalService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ROOT_ELEMENT]
+                }] }, { type: i3.IConfiguration, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [BASE_CONFIG]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [SCRIPT_PARAMS]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.service.js","sourceRoot":"","sources":["../../../../src/ngx-utils/services/config.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, Optional, isDevMode} from \"@angular/core\";\r\nimport {HttpClient} from \"@angular/common/http\";\r\nimport {UniversalService} from \"./universal.service\";\r\nimport {BASE_CONFIG, IConfigService, IConfiguration, ROOT_ELEMENT, SCRIPT_PARAMS} from \"../common-types\";\r\n\r\nconst JSON5 = require(\"json5\");\r\n\r\n@Injectable()\r\nexport class ConfigService implements IConfigService {\r\n\r\n    protected baseConfig: IConfiguration;\r\n    protected loadedConfig: IConfiguration;\r\n    protected scriptParameters: any;\r\n    protected loader: Promise<IConfiguration>;\r\n    protected readonly loaderFunc: () => Promise<IConfiguration>;\r\n\r\n    get load(): () => Promise<IConfiguration> {\r\n        return this.loaderFunc;\r\n    }\r\n\r\n    get config(): IConfiguration {\r\n        return this.loadedConfig;\r\n    }\r\n\r\n    get configUrl(): string {\r\n        return `${this.loadedConfig.baseUrl}config/config.json`;\r\n    }\r\n\r\n    constructor(readonly http: HttpClient,\r\n                readonly universal: UniversalService,\r\n                @Inject(ROOT_ELEMENT) readonly rootElement: any,\r\n                @Optional() @Inject(BASE_CONFIG) baseConfig: IConfiguration = null,\r\n                @Optional() @Inject(SCRIPT_PARAMS) scriptParams: any = null) {\r\n        for (const key in []) {\r\n            Object.defineProperty(Array.prototype, key, {\r\n                enumerable: false\r\n            });\r\n        }\r\n        let baseUrl = \"\";\r\n        if (this.universal.isBrowser) {\r\n            const currentScript = (document.currentScript as HTMLScriptElement);\r\n            if (!!currentScript) {\r\n                const scriptSrc = currentScript.src;\r\n                const srcParts = scriptSrc.split(\".js\");\r\n                baseUrl = scriptSrc.substr(0, srcParts[0].lastIndexOf(\"/\") + 1);\r\n            }\r\n        }\r\n        this.baseConfig = baseConfig || {};\r\n        this.loadedConfig = Object.assign(\r\n            !baseUrl ? {} : {baseUrl, baseDomain: this.parseDomain(baseUrl)},\r\n            this.baseConfig\r\n        );\r\n        this.scriptParameters = scriptParams || {};\r\n        this.loaderFunc = () => {\r\n            this.loader = this.loader || new Promise<any>((resolve, reject) => {\r\n                this.loadJson().then(config => {\r\n                    this.loadedConfig = config = Object.assign(this.loadedConfig, config);\r\n                    this.prepareConfig(config).then(c => {\r\n                        this.loadedConfig = c;\r\n                        c.baseUrl = c.baseUrl || \"/\";\r\n                        resolve(c);\r\n                    });\r\n                }, reject);\r\n            });\r\n            return this.loader;\r\n        };\r\n        this.initService();\r\n    }\r\n\r\n    protected parseDomain(baseUrl: string): string {\r\n        try {\r\n            const url = new URL(baseUrl);\r\n            const port = url.port && url.port !== \"443\" && url.port !== \"80\" ? `:${url.port}` : ``;\r\n            return `${url.protocol}//${url.hostname}${port}/`;\r\n        } catch {\r\n            return \"/\";\r\n        }\r\n    }\r\n\r\n    protected initService(): void {\r\n\r\n    }\r\n\r\n    protected async loadJson(): Promise<IConfiguration> {\r\n        if (this.universal.isServer) {\r\n            return Promise.resolve(this.loadedConfig);\r\n        }\r\n        const configUrl = this.configUrl;\r\n        try {\r\n            const config5 = await this.http.get(isDevMode() ? `${configUrl}5` : configUrl, {responseType: \"text\"}).toPromise();\r\n            return JSON5.parse(config5);\r\n        } catch (e) {\r\n            try {\r\n                const config = await this.http.get(configUrl).toPromise();\r\n                console.log(`Can't parse json5 config: ${e}`);\r\n                return config;\r\n            } catch (e) {\r\n                throw new Error(`Config file not found at: ${configUrl}`);\r\n            }\r\n        }\r\n    }\r\n\r\n    protected prepareConfig(config: IConfiguration): Promise<IConfiguration> {\r\n        return Promise.resolve(config);\r\n    }\r\n\r\n    prepareUrl(url: string, ending: string): string {\r\n        const project = !this.loadedConfig ? \"\" : this.loadedConfig.project;\r\n        const needsProtocol = url?.startsWith(\"//\") ?? false;\r\n        url = !needsProtocol && url?.startsWith(\"/\") ? this.loadedConfig.baseDomain + url.substr(1) : url || \"\";\r\n        url = `${url.replace(/\\/+$/, \"\")}${ending}`.replace(\"[project]\", project);\r\n        return this.universal.isServer && needsProtocol ? `http:${url}` : url;\r\n    }\r\n\r\n    getConfigValue(key: string): any {\r\n        return this.loadedConfig[key];\r\n    }\r\n\r\n    getQueryParameter(name: string, url?: string): string {\r\n        url = url || (this.universal.isBrowser ? window.location.href : \"\");\r\n        name = name.replace(/[\\[\\]]/g, \"\\\\$&\");\r\n        const regex = new RegExp(\"[?&]\" + name + \"(=([^&#]*)|&|#|$)\"),\r\n            results = regex.exec(url);\r\n        if (!results) return null;\r\n        if (!results[2]) return \"\";\r\n        return decodeURIComponent(results[2].replace(/\\+/g, \" \"));\r\n    }\r\n}\r\n"]}

package/esm2020/ngx-utils/services/error-handler.service.mjs

@@ -0,0 +1,49 @@
+import { ErrorHandler, Injectable, Injector } from "@angular/core";
+import { UniversalService } from "./universal.service";
+import { ERROR_HANDLER, TOASTER_SERVICE } from "../common-types";
+import * as i0 from "@angular/core";
+export class ErrorHandlerService extends ErrorHandler {
+    constructor(injector) {
+        super();
+        this.injector = injector;
+        this.errorMap = {};
+    }
+    handleError(error) {
+        try {
+            this.universal = this.universal || this.injector.get(UniversalService);
+        }
+        catch (e) {
+            return;
+        }
+        const date = new Date();
+        try {
+            this.errorCb = this.errorCb || this.injector.get(ERROR_HANDLER);
+            this.errorCb(`[${date}]: ${error.message}\n${error.stack}`);
+        }
+        catch (e) {
+            if (this.universal.isServer) {
+                console.error(`[${date}]: ${error.message}\n${error.stack}`);
+                return;
+            }
+        }
+        if (this.universal.isServer)
+            return;
+        const key = typeof btoa !== "undefined" ? btoa(unescape(encodeURIComponent(`${error.message} ${error.stack}`))) : error.message;
+        if (this.errorMap[key] && this.errorMap[key].getTime() > date.getTime() - 5000)
+            return;
+        this.errorMap[key] = date;
+        try {
+            this.toaster = this.toaster || this.injector.get(TOASTER_SERVICE);
+            this.toaster.error(`[${date}]: ${error.message}\n${error.stack}`);
+        }
+        catch (e) {
+        }
+        console.error(`[${date}]: ${error.message}\n${error.stack}`);
+    }
+}
+ErrorHandlerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ErrorHandlerService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+ErrorHandlerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ErrorHandlerService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ErrorHandlerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/services/events.service.mjs

@@ -0,0 +1,26 @@
+import { EventEmitter, Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class EventsService {
+    constructor() {
+        this.eventForwarded = new EventEmitter();
+        this.stickyUpdated = new EventEmitter();
+        this.languageChanged = new EventEmitter();
+        this.sticky = false;
+    }
+    get isSticky() {
+        return this.sticky;
+    }
+    event(e) {
+        this.eventForwarded.emit(e);
+    }
+    updateSticky(sticky) {
+        this.sticky = sticky;
+        this.stickyUpdated.emit(sticky);
+    }
+}
+EventsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: EventsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+EventsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: EventsService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: EventsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/services/formatter.service.mjs

@@ -0,0 +1,47 @@
+import { Inject, Injectable } from "@angular/core";
+import { LANGUAGE_SERVICE } from "../common-types";
+import { ObjectUtils } from "../utils/object.utils";
+import { MathUtils } from "../utils/math.utils";
+import * as i0 from "@angular/core";
+export class FormatterService {
+    constructor(language) {
+        this.language = language;
+    }
+    get defaultPrecision() {
+        return 2;
+    }
+    get defaultNumberFormat() {
+        return `num + ' mm'`;
+    }
+    get defaultDivider() {
+        return 1;
+    }
+    roundNumber(value, precision, divider) {
+        return MathUtils.round(value, this.getPrecision(precision), divider || this.defaultDivider);
+    }
+    formatNumber(value, format, precision, divider) {
+        precision = this.getPrecision(precision);
+        divider = divider || this.defaultDivider;
+        const num = ObjectUtils.isNumber(value) ? value : parseFloat(value) || 0;
+        const str = (num / divider).toLocaleString(this.language.currentLanguage, {
+            minimumFractionDigits: precision,
+            maximumFractionDigits: precision
+        });
+        return ObjectUtils.evaluate(format || this.defaultNumberFormat, { num: str });
+    }
+    formatMillimeter(value, precision, divider) {
+        return this.formatNumber(value, `num + ' mm'`, precision, divider);
+    }
+    getPrecision(precision) {
+        return ObjectUtils.isNumber(precision) ? precision : this.defaultPrecision;
+    }
+}
+FormatterService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: FormatterService, deps: [{ token: LANGUAGE_SERVICE }], target: i0.ɵɵFactoryTarget.Injectable });
+FormatterService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: FormatterService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: FormatterService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LANGUAGE_SERVICE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/services/global-template.service.mjs

@@ -0,0 +1,37 @@
+import { EventEmitter, Injectable } from "@angular/core";
+import { ObjectUtils } from "../utils/object.utils";
+import * as i0 from "@angular/core";
+export class GlobalTemplateService {
+    constructor() {
+        this.templatesUpdated = new EventEmitter();
+        this.globalTemplates = {};
+        this.componentModifiers = {};
+    }
+    get(id, component) {
+        const template = this.globalTemplates[id];
+        if (!template)
+            return undefined;
+        const modifier = this.componentModifiers[id];
+        if (ObjectUtils.isFunction(modifier) && component) {
+            modifier(component);
+        }
+        return template;
+    }
+    add(id, template) {
+        this.globalTemplates[id] = template;
+        this.templatesUpdated.emit();
+    }
+    remove(id) {
+        delete this.globalTemplates[id];
+        this.templatesUpdated.emit();
+    }
+    addComponentModifier(id, modifier) {
+        this.componentModifiers[id] = modifier;
+    }
+}
+GlobalTemplateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: GlobalTemplateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+GlobalTemplateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: GlobalTemplateService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: GlobalTemplateService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/services/icon.service.mjs

@@ -0,0 +1,26 @@
+import { EventEmitter, Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class IconService {
+    constructor() {
+        this.iconsLoaded = new EventEmitter();
+        this.disabled = false;
+    }
+    get isDisabled() {
+        return this.disabled;
+    }
+    set isDisabled(value) {
+        this.disabled = value;
+        this.iconsLoaded.emit();
+    }
+    getIcon(icon, activeIcon, active) {
+        icon = typeof icons == "undefined" ? icon : (icons[icon] || icon);
+        activeIcon = typeof icons == "undefined" ? activeIcon : (icons[activeIcon] || icon);
+        return Promise.resolve(active ? activeIcon : icon);
+    }
+}
+IconService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: IconService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+IconService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: IconService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: IconService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/services/language.service.mjs

@@ -0,0 +1,113 @@
+import { Injectable } from "@angular/core";
+import { BehaviorSubject, combineLatest } from "rxjs";
+import { map } from "rxjs/operators";
+import { StaticLanguageService } from "./static-language.service";
+import * as i0 from "@angular/core";
+export class LanguageService extends StaticLanguageService {
+    get currentLanguage() {
+        return this.currentLang || this.defaultLanguage;
+    }
+    set currentLanguage(lang) {
+        this.useLanguage(lang).then(() => {
+            this.events.languageChanged.emit(lang);
+        });
+    }
+    get settings() {
+        const settings = this.languageSettings.value;
+        return !settings ? {} : settings.settings[this.currentLanguage] || {};
+    }
+    get $settings() {
+        this.loadSettings().then(s => this.languageSettings.next(s));
+        return combineLatest([this.languageSettings, this.events.languageChanged]).pipe(map(([settings, lang]) => {
+            return !settings ? {} : settings.settings[lang] || {};
+        }));
+    }
+    initService() {
+        this.client.setExtraRequestParam("language", "de");
+        this.translationRequests = {};
+        this.languageSettings = new BehaviorSubject(null);
+        if (this.universal.isServer)
+            return;
+        window["setLanguage"] = (lang) => {
+            this.currentLanguage = lang;
+        };
+    }
+    async initFromSettings() {
+        const defaultLanguage = this.defaultLanguage;
+        const settings = await this.loadSettings();
+        this.languageSettings.next(settings);
+        const devLanguages = settings.devLanguages || [];
+        this.languageList = (settings.languages || []).filter(lang => {
+            return devLanguages.indexOf(lang) < 0;
+        });
+        const lang = this.languages.indexOf(defaultLanguage) < 0 ? settings.defaultLanguage : defaultLanguage;
+        await this.useLanguage(lang);
+        this.events.languageChanged.emit(lang);
+    }
+    async getTranslation(key, params = null) {
+        if (!key)
+            return "";
+        try {
+            const lowerKey = key.toLocaleLowerCase();
+            const dict = await this.loadDictionary();
+            if (lowerKey in dict) {
+                return this.interpolate(dict[lowerKey], params);
+            }
+            return this.interpolate(key, params);
+        }
+        catch (reason) {
+            console.log("ERROR IN TRANSLATIONS", reason);
+            return key;
+        }
+    }
+    async useLanguage(lang) {
+        lang = this.languages.indexOf(lang) < 0 ? this.languages[0] : lang;
+        this.client.setExtraRequestParam("language", lang);
+        if (lang == this.currentLang)
+            return this.dictionary;
+        this.storage.set("language", lang);
+        this.currentLang = lang;
+        const dict = await this.loadDictionary();
+        this.translations[lang] = dict;
+        return dict;
+    }
+    loadDictionary() {
+        const lang = this.currentLanguage;
+        this.translationRequests[lang] = this.translationRequests[lang] || new Promise(resolve => {
+            this.httpClient.get(`${this.config.translationUrl}${lang}`).toPromise().then(response => {
+                response = response || {};
+                resolve(Object.keys(response).reduce((result, key) => {
+                    result[key.toLocaleLowerCase()] = response[key];
+                    return result;
+                }, {}));
+            }, () => {
+                resolve({});
+            });
+        });
+        return this.translationRequests[lang];
+    }
+    loadSettings() {
+        this.settingsPromise = this.settingsPromise || this.client.get(`${this.config.translationUrl}languageSettings`).toPromise()
+            .then((settings) => {
+            return settings;
+        }, () => {
+            return {
+                languages: ["de", "en", "hu"],
+                devLanguages: [],
+                defaultLanguage: "de",
+                settings: {
+                    de: {},
+                    hu: {},
+                    end: {}
+                }
+            };
+        });
+        return this.settingsPromise;
+    }
+}
+LanguageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: LanguageService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+LanguageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: LanguageService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: LanguageService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"language.service.js","sourceRoot":"","sources":["../../../../src/ngx-utils/services/language.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from \"@angular/core\";\r\nimport {BehaviorSubject, combineLatest, Observable} from \"rxjs\";\r\nimport {map} from \"rxjs/operators\";\r\nimport {ILanguageSettings, ITranslations} from \"../common-types\";\r\nimport {StaticLanguageService} from \"./static-language.service\";\r\n\r\n@Injectable()\r\nexport class LanguageService extends StaticLanguageService {\r\n\r\n    protected translationRequests: ITranslations;\r\n    protected settingsPromise: Promise<ILanguageSettings>;\r\n    protected languageSettings: BehaviorSubject<ILanguageSettings>;\r\n\r\n    get currentLanguage(): string {\r\n        return this.currentLang || this.defaultLanguage;\r\n    }\r\n\r\n    set currentLanguage(lang: string) {\r\n        this.useLanguage(lang).then(() => {\r\n            this.events.languageChanged.emit(lang);\r\n        });\r\n    }\r\n\r\n    get settings(): ILanguageSettings {\r\n        const settings = this.languageSettings.value;\r\n        return !settings ? {} : settings.settings[this.currentLanguage] || {};\r\n    }\r\n\r\n    get $settings(): Observable<any> {\r\n        this.loadSettings().then(s => this.languageSettings.next(s));\r\n        return combineLatest([this.languageSettings, this.events.languageChanged]).pipe(map(([settings, lang]) => {\r\n            return !settings ? {} : settings.settings[lang as string] || {};\r\n        }));\r\n    }\r\n\r\n    protected initService(): void {\r\n        this.client.setExtraRequestParam(\"language\", \"de\");\r\n        this.translationRequests = {};\r\n        this.languageSettings = new BehaviorSubject<ILanguageSettings>(null);\r\n        if (this.universal.isServer) return;\r\n        window[\"setLanguage\"] = (lang: string) => {\r\n            this.currentLanguage = lang;\r\n        };\r\n    }\r\n\r\n    async initFromSettings(): Promise<any> {\r\n        const defaultLanguage = this.defaultLanguage;\r\n        const settings = await this.loadSettings();\r\n        this.languageSettings.next(settings);\r\n        const devLanguages = settings.devLanguages || [];\r\n        this.languageList = (settings.languages || []).filter(lang => {\r\n            return devLanguages.indexOf(lang) < 0;\r\n        });\r\n        const lang = this.languages.indexOf(defaultLanguage) < 0 ? settings.defaultLanguage : defaultLanguage;\r\n        await this.useLanguage(lang);\r\n        this.events.languageChanged.emit(lang);\r\n    }\r\n\r\n    async getTranslation(key: string, params: any = null): Promise<string> {\r\n        if (!key) return \"\";\r\n        try {\r\n            const lowerKey = key.toLocaleLowerCase();\r\n            const dict = await this.loadDictionary();\r\n            if (lowerKey in dict) {\r\n                return this.interpolate(dict[lowerKey], params);\r\n            }\r\n            return this.interpolate(key, params);\r\n        } catch (reason) {\r\n            console.log(\"ERROR IN TRANSLATIONS\", reason);\r\n            return key;\r\n        }\r\n    }\r\n\r\n    protected async useLanguage(lang: string): Promise<ITranslations> {\r\n        lang = this.languages.indexOf(lang) < 0 ? this.languages[0] : lang;\r\n        this.client.setExtraRequestParam(\"language\", lang);\r\n        if (lang == this.currentLang) return this.dictionary;\r\n        this.storage.set(\"language\", lang);\r\n        this.currentLang = lang;\r\n        const dict = await this.loadDictionary();\r\n        this.translations[lang] = dict;\r\n        return dict;\r\n    }\r\n\r\n    protected loadDictionary(): Promise<any> {\r\n        const lang = this.currentLanguage;\r\n        this.translationRequests[lang] = this.translationRequests[lang] || new Promise(resolve => {\r\n            this.httpClient.get(`${this.config.translationUrl}${lang}`).toPromise().then(response => {\r\n                response = response || {};\r\n                resolve(Object.keys(response).reduce((result, key) => {\r\n                    result[key.toLocaleLowerCase()] = response[key];\r\n                    return result;\r\n                }, {}));\r\n            }, () => {\r\n                resolve({});\r\n            });\r\n        });\r\n        return this.translationRequests[lang];\r\n    }\r\n\r\n    protected loadSettings(): Promise<ILanguageSettings> {\r\n        this.settingsPromise = this.settingsPromise || this.client.get(`${this.config.translationUrl}languageSettings`).toPromise()\r\n            .then(\r\n                (settings: ILanguageSettings) => {\r\n                    return settings;\r\n                }, () => {\r\n                    return {\r\n                        languages: [\"de\", \"en\", \"hu\"],\r\n                        devLanguages: [],\r\n                        defaultLanguage: \"de\",\r\n                        settings: {\r\n                            de: {},\r\n                            hu: {},\r\n                            end: {}\r\n                        }\r\n                    };\r\n                }\r\n            );\r\n        return this.settingsPromise;\r\n    }\r\n}\r\n"]}

package/esm2020/ngx-utils/services/open-api.service.mjs

@@ -0,0 +1,40 @@
+import { Inject, Injectable } from "@angular/core";
+import { API_SERVICE } from "../common-types";
+import * as i0 from "@angular/core";
+export class OpenApiService {
+    constructor(api) {
+        this.api = api;
+    }
+    getSchemas() {
+        this.schemasPromise = this.schemasPromise || new Promise((resolve => {
+            this.api.get("api-docs").then(res => {
+                const schemas = res.components?.schemas || res.definitions || {};
+                Object.values(schemas).forEach(schema => {
+                    Object.keys(schema.properties || {}).forEach(p => {
+                        schema.properties[p].id = p;
+                    });
+                });
+                resolve(schemas);
+            }, () => {
+                resolve({});
+            });
+        }));
+        return this.schemasPromise;
+    }
+    async getSchema(name) {
+        const schemas = await this.getSchemas();
+        const schema = schemas[name];
+        if (!schema)
+            return null;
+        return schemas[name];
+    }
+}
+OpenApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: OpenApiService, deps: [{ token: API_SERVICE }], target: i0.ɵɵFactoryTarget.Injectable });
+OpenApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: OpenApiService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: OpenApiService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [API_SERVICE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/services/promise.service.mjs

@@ -0,0 +1,55 @@
+import { EventEmitter, Inject, Injectable, NgZone } from "@angular/core";
+import * as i0 from "@angular/core";
+export class PromiseService {
+    constructor(zone) {
+        this.zone = zone;
+        this.promiseCount = 0;
+        this.promiseChanged = new EventEmitter();
+    }
+    get count() {
+        return this.promiseCount;
+    }
+    get onChanged() {
+        return this.promiseChanged;
+    }
+    create(executor) {
+        return this.add(this.zone.runOutsideAngular(() => new Promise(executor)));
+    }
+    all(promises) {
+        return this.add(this.zone.runOutsideAngular(() => Promise.all(promises)));
+    }
+    resolve(value) {
+        return this.add(this.zone.runOutsideAngular(() => Promise.resolve(value)));
+    }
+    reject(value) {
+        return this.add(this.zone.runOutsideAngular(() => Promise.reject(value)));
+    }
+    promiseFinished() {
+        if (this.promiseCount == 0)
+            return;
+        this.promiseCount--;
+        this.promiseChanged.emit(this.promiseCount);
+    }
+    add(promise) {
+        this.promiseCount++;
+        this.promiseChanged.emit(this.promiseCount);
+        return new Promise((resolve, reject) => {
+            promise.then(v => {
+                resolve(v);
+                this.promiseFinished();
+            }, r => {
+                reject(r);
+                this.promiseFinished();
+            });
+        });
+    }
+}
+PromiseService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: PromiseService, deps: [{ token: NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+PromiseService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: PromiseService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: PromiseService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.NgZone, decorators: [{
+                    type: Inject,
+                    args: [NgZone]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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