@stemy/ngx-utils 13.1.1 → 13.1.4

package/esm2015/ngx-utils/services/config.service.js

@@ -0,0 +1,122 @@
+import { __awaiter } from "tslib";
+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";
+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 (_a) {
+            return "/";
+        }
+    }
+    initService() {
+    }
+    loadJson() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.universal.isServer) {
+                return Promise.resolve(this.loadedConfig);
+            }
+            const configUrl = this.configUrl;
+            try {
+                const config5 = yield this.http.get(isDevMode() ? `${configUrl}5` : configUrl, { responseType: "text" }).toPromise();
+                return JSON5.parse(config5);
+            }
+            catch (e) {
+                try {
+                    const config = yield 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) {
+        var _a;
+        const project = !this.loadedConfig ? "" : this.loadedConfig.project;
+        const needsProtocol = (_a = url === null || url === void 0 ? void 0 : url.startsWith("//")) !== null && _a !== void 0 ? _a : false;
+        url = !needsProtocol && (url === null || url === void 0 ? void 0 : 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.decorators = [
+    { type: Injectable }
+];
+ConfigService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: UniversalService },
+    { type: undefined, decorators: [{ type: Inject, args: [ROOT_ELEMENT,] }] },
+    { type: 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/esm2015/ngx-utils/services/error-handler.service.js

@@ -0,0 +1,49 @@
+import { ErrorHandler, Injectable, Injector } from "@angular/core";
+import { UniversalService } from "./universal.service";
+import { ERROR_HANDLER, TOASTER_SERVICE } from "../common-types";
+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.decorators = [
+    { type: Injectable }
+];
+ErrorHandlerService.ctorParameters = () => [
+    { type: Injector }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/ngx-utils/services/events.service.js

@@ -0,0 +1,24 @@
+import { EventEmitter, Injectable } 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.decorators = [
+    { type: Injectable }
+];
+EventsService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/ngx-utils/services/formatter.service.js

@@ -0,0 +1,44 @@
+import { Inject, Injectable } from "@angular/core";
+import { LANGUAGE_SERVICE } from "../common-types";
+import { ObjectUtils } from "../utils/object.utils";
+import { MathUtils } from "../utils/math.utils";
+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.decorators = [
+    { type: Injectable }
+];
+FormatterService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [LANGUAGE_SERVICE,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/ngx-utils/services/global-template.service.js

@@ -0,0 +1,35 @@
+import { EventEmitter, Injectable } from "@angular/core";
+import { ObjectUtils } from "../utils/object.utils";
+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.decorators = [
+    { type: Injectable }
+];
+GlobalTemplateService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/ngx-utils/services/icon.service.js

@@ -0,0 +1,24 @@
+import { EventEmitter, Injectable } 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.decorators = [
+    { type: Injectable }
+];
+IconService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/ngx-utils/services/language.service.js

@@ -0,0 +1,117 @@
+import { __awaiter } from "tslib";
+import { Injectable } from "@angular/core";
+import { BehaviorSubject, combineLatest } from "rxjs";
+import { map } from "rxjs/operators";
+import { StaticLanguageService } from "./static-language.service";
+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;
+        };
+    }
+    initFromSettings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const defaultLanguage = this.defaultLanguage;
+            const settings = yield 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;
+            yield this.useLanguage(lang);
+            this.events.languageChanged.emit(lang);
+        });
+    }
+    getTranslation(key, params = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!key)
+                return "";
+            try {
+                const lowerKey = key.toLocaleLowerCase();
+                const dict = yield 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;
+            }
+        });
+    }
+    useLanguage(lang) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = yield 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.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/esm2015/ngx-utils/services/open-api.service.js

@@ -0,0 +1,41 @@
+import { __awaiter } from "tslib";
+import { Inject, Injectable } from "@angular/core";
+import { API_SERVICE } from "../common-types";
+export class OpenApiService {
+    constructor(api) {
+        this.api = api;
+    }
+    getSchemas() {
+        this.schemasPromise = this.schemasPromise || new Promise((resolve => {
+            this.api.get("api-docs").then(res => {
+                var _a;
+                const schemas = ((_a = res.components) === null || _a === void 0 ? void 0 : _a.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;
+    }
+    getSchema(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schemas = yield this.getSchemas();
+            const schema = schemas[name];
+            if (!schema)
+                return null;
+            return schemas[name];
+        });
+    }
+}
+OpenApiService.decorators = [
+    { type: Injectable }
+];
+OpenApiService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [API_SERVICE,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/ngx-utils/services/promise.service.js

@@ -0,0 +1,52 @@
+import { EventEmitter, Inject, Injectable, NgZone } 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.decorators = [
+    { type: Injectable }
+];
+PromiseService.ctorParameters = () => [
+    { type: NgZone, decorators: [{ type: Inject, args: [NgZone,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,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