@stemy/ngx-utils 17.5.0 → 17.5.2

package/fesm2022/stemy-ngx-utils.mjs

@@ -1931,57 +1931,69 @@ class Initializer {
 }
 
 class LoaderUtils {
-    static { this.scriptPromises = {}; }
-    static { this.stylePromises = {}; }
-    static loadScript(src, async = false, type = "text/javascript") {
-        this.scriptPromises[src] = this.scriptPromises[src] || new Promise((resolve, reject) => {
-            // Load script
+    static { this.promises = {}; }
+    static loadScript(src, async = false, type = "text/javascript", parent, time = false) {
+        return LoaderUtils.loadElement(src, parent, time, url => {
             const script = document.createElement("script");
             script.type = type;
-            script.src = src;
+            script.src = url;
             script.async = async;
-            if (script.readyState) {
-                // Internet explorer
-                script.onreadystatechange = () => {
-                    if (script.readyState === "loaded" || script.readyState === "complete") {
-                        script.onreadystatechange = null;
-                        resolve(script);
-                    }
-                };
-            }
-            else {
-                // Other browsers
-                script.onload = () => resolve(script);
-            }
-            script.onerror = (error) => reject(error);
-            document.body.appendChild(script);
+            return script;
         });
-        return this.scriptPromises[src];
     }
-    static loadStyle(src) {
-        this.stylePromises[src] = this.stylePromises[src] || new Promise((resolve, reject) => {
-            // Load script
+    static loadStyle(src, parent, time = false) {
+        return LoaderUtils.loadElement(src, parent, time, url => {
             const link = document.createElement("link");
             link.rel = "stylesheet";
             link.type = "text/css";
-            link.href = src;
-            if (link.readyState) {
+            link.href = url;
+            return link;
+        });
+    }
+    static updateSrc(src, time) {
+        const srcStr = String(src || "");
+        if (srcStr.startsWith("data:") || !time) {
+            return srcStr;
+        }
+        const url = new URL(src);
+        url.searchParams.set("time", typeof time === "string" ? time : String(Date.now()));
+        return url.toString();
+    }
+    static loadElement(url, parent, time, setup) {
+        const promises = LoaderUtils.promises;
+        const src = LoaderUtils.updateSrc(url, time);
+        parent = parent || document;
+        if (parent == document) {
+            parent = document.body;
+        }
+        let { elem, promise } = promises[src] || {};
+        if (elem) {
+            if (parent === elem.parentElement)
+                return promise;
+            if (elem.parentElement) {
+                elem.remove();
+            }
+        }
+        elem = setup(src);
+        promise = new Promise((resolve, reject) => {
+            if (elem.readyState) {
                 // Internet explorer
-                link.onreadystatechange = () => {
-                    if (link.readyState === "loaded" || link.readyState === "complete") {
-                        link.onreadystatechange = null;
-                        resolve(link);
+                elem.onreadystatechange = () => {
+                    if (elem.readyState === "loaded" || elem.readyState === "complete") {
+                        elem.onreadystatechange = null;
+                        resolve(elem);
                     }
                 };
             }
             else {
                 // Other browsers
-                link.onload = () => resolve(link);
+                elem.onload = () => resolve(elem);
             }
-            link.onerror = (error) => reject(error);
-            document.body.appendChild(link);
+            elem.onerror = (error) => reject(error);
         });
-        return this.stylePromises[src];
+        parent.appendChild(elem);
+        promises[src] = { elem, promise };
+        return promise;
     }
 }
 
@@ -3269,19 +3281,28 @@ class EventsService {
     get isSticky() {
         return this.sticky;
     }
+    get isAuthenticated() {
+        return !!this.user;
+    }
     constructor() {
-        this.eventForwarded = new EventEmitter();
-        this.stickyUpdated = new EventEmitter();
-        this.languageChanged = new EventEmitter();
-        this.editLanguageChanged = new EventEmitter();
+        this.eventForwarded = new Subject();
+        this.stickyUpdated = new Subject();
+        this.languageChanged = new Subject();
+        this.editLanguageChanged = new Subject();
+        this.translationsEnabled = new Subject();
+        this.userChanged = new Subject();
         this.sticky = false;
+        this.user = null;
+        this.userChanged.subscribe(user => {
+            this.user = user;
+        });
     }
     event(e) {
-        this.eventForwarded.emit(e);
+        this.eventForwarded.next(e);
     }
     updateSticky(sticky) {
         this.sticky = sticky;
-        this.stickyUpdated.emit(sticky);
+        this.stickyUpdated.next(sticky);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EventsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EventsService }); }
@@ -3392,16 +3413,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
             type: Injectable
         }], ctorParameters: () => [] });
 
-const emptyDict = {};
+const EMPTY_DICT = {};
 class StaticLanguageService {
     get defaultLanguage() {
         return this.configs.getQueryParameter("lang") || this.storage.get("language", this.getDefaultLanguage());
     }
     get dictionary() {
-        return this.mergedTranslations[this.currentLanguage] || emptyDict;
+        return this.mergedTranslations[this.currentLanguage] || EMPTY_DICT;
     }
     set dictionary(value) {
-        this.translations[this.currentLanguage] = value;
+        this.setDictionary(this.currentLang, value);
         this.mergeTranslations();
     }
     get languages() {
@@ -3412,21 +3433,27 @@ class StaticLanguageService {
     }
     set currentLanguage(lang) {
         this.currentLang = lang;
-        this.events.languageChanged.emit(lang);
+        this.events.languageChanged.next(lang);
     }
     get editLanguage() {
         return this.editLang || this.currentLanguage;
     }
     set editLanguage(lang) {
         this.editLang = lang || this.currentLanguage;
-        this.events.editLanguageChanged.emit(this.editLang);
+        this.events.editLanguageChanged.next(this.editLang);
+    }
+    get enableTranslations() {
+        return this.enableTrans;
+    }
+    set enableTranslations(value) {
+        this.enableTrans = value;
+        this.events.translationsEnabled.next(value);
     }
     get disableTranslations() {
-        return this.disableTrans;
+        return !this.enableTranslations;
     }
     set disableTranslations(value) {
-        this.disableTrans = value;
-        this.events.languageChanged.emit(this.currentLang);
+        this.enableTranslations = !value;
     }
     get httpClient() {
         return this.client;
@@ -3445,7 +3472,7 @@ class StaticLanguageService {
         this.client = client;
         this.editLang = null;
         this.currentLang = null;
-        this.disableTrans = false;
+        this.enableTrans = true;
         this.languageList = [];
         this.translations = {
             none: {}
@@ -3462,7 +3489,7 @@ class StaticLanguageService {
         languages = Array.isArray(languages) && languages.length > 0 ? languages : this.languageList;
         this.languageList = Array.from(new Set(languages));
         this.languageList.forEach(lang => {
-            this.translations[lang] = this.translations[lang] || emptyDict;
+            this.translations[lang] = this.translations[lang] || EMPTY_DICT;
         });
     }
     addLanguages(languages) {
@@ -3480,12 +3507,24 @@ class StaticLanguageService {
         this.mergedTranslations = this.translations;
     }
     getTranslationSync(key, params = null) {
-        key = String(key || "");
-        const lowerKey = key.toLocaleLowerCase();
-        const translation = !key ? "" : this.dictionary[lowerKey] || key;
-        return this.interpolate(translation, params);
+        key = String(key ?? "");
+        if (!key)
+            return "";
+        try {
+            const lowerKey = key.toLocaleLowerCase();
+            const dict = this.dictionary;
+            if (lowerKey in dict && this.enableTranslations) {
+                return this.interpolate(dict[lowerKey], params);
+            }
+            return this.interpolate(key, params);
+        }
+        catch (reason) {
+            console.warn("ERROR IN TRANSLATIONS", reason);
+            return key;
+        }
     }
-    async getTranslation(key, params) {
+    async getTranslation(key, params = null) {
+        await this.loadDictionary();
         return this.getTranslationSync(key, params);
     }
     getTranslations(...keys) {
@@ -3507,9 +3546,20 @@ class StaticLanguageService {
         const translation = translations ? translations.find(t => t.lang == lang) : null;
         return this.interpolate(translation ? translation.translation : "", params);
     }
+    async loadDictionary() {
+        return this.dictionary;
+    }
+    setDictionary(lang, dictionary) {
+        this.translations[lang] = Object.keys(dictionary || {}).reduce((res, key) => {
+            res[key.toLocaleLowerCase()] = dictionary[key];
+            return res;
+        }, {});
+        return this.translations[lang];
+    }
     interpolate(expr, params) {
         if (typeof expr === "string") {
-            return this.interpolateString(expr, params);
+            // Force single spaces to be empty strings, for labeling in forms.
+            return expr === " " ? "" : this.interpolateString(expr, params);
         }
         if (typeof expr === "function") {
             return expr(params);
@@ -3520,7 +3570,7 @@ class StaticLanguageService {
         if (!expr || !params)
             return expr;
         return expr.replace(/{{\s?([^{}\s]*)\s?}}/g, (substring, b) => {
-            const r = ObjectUtils.getValue(params, b);
+            const r = ObjectUtils.getValue(params, b, "");
             return ObjectUtils.isDefined(r) ? r : substring;
         });
     }
@@ -3546,8 +3596,8 @@ class StaticLanguageService {
         ]);
         this.mergedTranslations = Array.from(languages).reduce((merged, language) => {
             merged[language] = {
-                ...(this.translations[language] || emptyDict),
-                ...(this.overrideTranslations[language] || emptyDict),
+                ...(this.translations[language] || EMPTY_DICT),
+                ...(this.overrideTranslations[language] || EMPTY_DICT),
             };
             return merged;
         }, {});
@@ -3580,7 +3630,7 @@ class LanguageService extends StaticLanguageService {
     }
     set currentLanguage(lang) {
         this.useLanguage(lang).then(() => {
-            this.events.languageChanged.emit(lang);
+            this.events.languageChanged.next(lang);
         });
     }
     get settings() {
@@ -3594,7 +3644,8 @@ class LanguageService extends StaticLanguageService {
         }));
     }
     initService() {
-        this.client.setExtraRequestParam("language", "de");
+        super.initService();
+        this.client.setExtraRequestParam("language", "en");
         this.translationRequests = {};
         this.languageSettings = new BehaviorSubject(null);
         if (this.universal.isServer)
@@ -3622,32 +3673,32 @@ class LanguageService extends StaticLanguageService {
         if (this.languageList.length === 0) {
             this.languageList = [defaultLanguage];
         }
-        const lang = this.languages.indexOf(defaultLanguage) < 0 ? settings.defaultLanguage || this.languageList[0] : defaultLanguage;
+        const lang = this.selectLanguage(this.currentLang)
+            ?? this.selectLanguage(defaultLanguage)
+            ?? this.selectLanguage(settings.defaultLanguage || this.languageList[0]);
         await this.useLanguage(lang);
-        this.events.languageChanged.emit(lang);
+        this.events.languageChanged.next(lang);
     }
-    async getTranslation(key, params = null) {
-        try {
-            await this.getDictionary();
-            return super.getTranslationSync(key, params);
-        }
-        catch (reason) {
-            console.log("ERROR IN TRANSLATIONS", reason);
-            return key;
-        }
+    selectLanguage(lang) {
+        if (!lang)
+            return null;
+        return this.languageList.length === 0 || this.languageList.includes(lang)
+            ? lang : null;
     }
     async useLanguage(lang) {
-        lang = this.languages.indexOf(lang) < 0 ? this.languages[0] : lang;
+        lang = this.selectLanguage(lang);
         this.client.setExtraRequestParam("language", lang);
-        if (lang == this.currentLang)
+        if (lang === this.currentLang)
             return this.dictionary;
         this.storage.set("language", lang);
         this.currentLang = lang;
-        return this.getDictionary();
+        return this.loadDictionary();
     }
-    getDictionary(lang) {
-        lang = this.languages.includes(lang) ? lang : this.currentLanguage;
-        this.translationRequests[lang] = this.translationRequests[lang] || firstValueFrom(this.client.get(`${this.config.translationUrl}${lang}`))
+    async getDictionary(lang) {
+        if (!lang)
+            return EMPTY_DICT;
+        const ext = this.config.translationExt || ``;
+        this.translationRequests[lang] = this.translationRequests[lang] || firstValueFrom(this.client.get(`${this.config.translationUrl}${lang}${ext}`))
             .then(response => {
             response = response || {};
             const dictionary = Object.keys(response).reduce((result, key) => {
@@ -3659,12 +3710,16 @@ class LanguageService extends StaticLanguageService {
             return dictionary;
         }).catch(error => {
             console.warn("Translation dictionary problem:", error);
-            return {};
+            return EMPTY_DICT;
         });
         return this.translationRequests[lang];
     }
+    async loadDictionary() {
+        return this.getDictionary(this.currentLang);
+    }
     loadSettings() {
-        this.settingsPromise = this.settingsPromise || firstValueFrom(this.client.get(`${this.config.translationUrl}languageSettings`))
+        const ext = this.config.translationExt || ``;
+        this.settingsPromise = this.settingsPromise || firstValueFrom(this.client.get(`${this.config.translationUrl}languageSettings${ext}`))
             .catch(error => {
             console.warn("Translation settings problem:", error);
             return {