@colijnit/sharedcomponents 1.0.56 → 1.0.57

package/esm2015/lib/service/dictionary.service.js

@@ -0,0 +1,76 @@
+import { __awaiter } from "tslib";
+import { Injectable } from "@angular/core";
+import { LanguageCode } from "../enum/language-code.enum";
+import { StringUtils } from "../utils/string-utils";
+import { Dictionary } from "../assets/dictionary/text.properties";
+import * as i0 from "@angular/core";
+// The localization service, providing peers with text translation functionality.
+export class DictionaryService {
+    constructor() {
+        this.dictionaryUrl = "js/browser/res/dictionary/";
+        // private _dictionaryPromise: Map<LanguageCode, Promise<{ [key: string]: string }>> = new Map<LanguageCode, Promise<{ [key: string]: string }>>();
+        this._dictionaries = new Map();
+        // Some dictionary values have one or more '|~' texts in them, meant to be replaced with client-side given texts.
+        this._placeholder = "|~";
+    }
+    get language() {
+        return this._language;
+    }
+    set rootUrl(value) {
+        this._rootUrl = value;
+        this._dictBasePath = this._rootUrl + "/" + this.dictionaryUrl;
+    }
+    // Loads the dictionary for given language in memory.
+    setDictionary(language) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._language = language || LanguageCode.Dutch;
+            this._loadDictionary();
+        });
+    }
+    _loadDictionary() {
+        if (!this._dictionaries.has(this._language)) {
+            const dictionary = new Dictionary();
+            // eslint-disable-next-line no-magic-numbers
+            if (dictionary.strings[this._language.substr(0, 2).toLowerCase()] !== undefined) {
+                // eslint-disable-next-line no-magic-numbers
+                this._dictionaries.set(this._language, dictionary.strings[this._language.substr(0, 2).toLowerCase()]);
+            }
+        }
+    }
+    /**
+     * Returns the localized text for the given dictionary key.
+     * @param {string} key
+     * @param {boolean} [upperCaseFirst = true] False for first letter lowercase, true for first letter uppercase for returned dict val
+     * @param {string[]} replacementTexts Rest params for replacement of '|~' in returned dict value
+     * @returns {string} The translated text for given dictionary key
+     */
+    get(key, upperCaseFirst = true, ...replacementTexts) {
+        if (!StringUtils.IsStringWithLength(key)) {
+            return key || "";
+        }
+        if (this.language === undefined) {
+            this._language = LanguageCode.Dutch;
+            this._loadDictionary();
+        }
+        let text = this._dictionaries.get(this.language)[key];
+        text = StringUtils.IsStringWithLength(text) ? text : key;
+        if (upperCaseFirst) {
+            text = text.charAt(0).toUpperCase() + text.slice(1);
+        }
+        else {
+            text = text.charAt(0).toLowerCase() + text.slice(1);
+        }
+        if (replacementTexts.length > 0) {
+            text = StringUtils.ReplaceOccurrencesIn(text, this._placeholder, ...replacementTexts);
+        }
+        return text;
+    }
+}
+DictionaryService.ɵprov = i0.ɵɵdefineInjectable({ factory: function DictionaryService_Factory() { return new DictionaryService(); }, token: DictionaryService, providedIn: "root" });
+DictionaryService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+DictionaryService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/service/icon-cache.service.js

@@ -0,0 +1,51 @@
+import { Injectable } from "@angular/core";
+import { DomSanitizer } from "@angular/platform-browser";
+import { IconSvg } from "../model/icon-svg";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+export class IconCacheService {
+    constructor(_sanitizer) {
+        this._sanitizer = _sanitizer;
+        this._iconCache = {};
+        this.setIconCache();
+    }
+    /**
+     * All the icons as a large JSON object, from the all-icons.json file.
+     * The object has property keys that are the icon names, and property values with the data string of the actual svg icon.
+     */
+    get iconCache() {
+        return this._iconCache;
+    }
+    getIcon(iconName) {
+        if (iconName) {
+            return this._iconCache[iconName.toLowerCase()];
+        }
+    }
+    getIconAsBase64(iconName) {
+        const icon = IconSvg[iconName];
+        const base64Data = window.btoa(icon);
+        return this._sanitizer.bypassSecurityTrustUrl(`data:image/svg+xml;base64,${base64Data}`);
+    }
+    getRawIcon(iconName) {
+        if (iconName) {
+            return IconSvg[iconName.toLowerCase()];
+        }
+    }
+    setIconCache() {
+        for (const key in IconSvg) {
+            if (IconSvg.hasOwnProperty(key) && typeof IconSvg[key] !== "function") {
+                this._iconCache[key.toLowerCase()] = this._sanitizer.bypassSecurityTrustHtml(IconSvg[key]);
+            }
+        }
+    }
+}
+IconCacheService.ɵprov = i0.ɵɵdefineInjectable({ factory: function IconCacheService_Factory() { return new IconCacheService(i0.ɵɵinject(i1.DomSanitizer)); }, token: IconCacheService, providedIn: "root" });
+IconCacheService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+IconCacheService.ctorParameters = () => [
+    { type: DomSanitizer }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/service/options.service.js

@@ -0,0 +1,48 @@
+import { __awaiter } from "tslib";
+import { Injectable } from "@angular/core";
+import { BehaviorSubject } from "rxjs";
+import { DictionaryService } from "./dictionary.service";
+import { SharedSettings } from '../model/settings';
+import * as i0 from "@angular/core";
+import * as i1 from "./dictionary.service";
+export class OptionsService {
+    constructor(_dictionary) {
+        this._dictionary = _dictionary;
+        this.optionsInitialized = new BehaviorSubject(false);
+        this.optionsLoaded = new BehaviorSubject(false);
+    }
+    set options(value) {
+        this._options = value;
+    }
+    get options() {
+        return this._options;
+    }
+    createSettingsFromObject(obj) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.options) {
+                this.options = new SharedSettings();
+            }
+            this.options = Object.assign(this.options, obj);
+            this.optionsLoaded.next(true);
+        });
+    }
+    initialize(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (options) {
+                yield this.createSettingsFromObject(options);
+                yield this._dictionary.setDictionary(this.options.languageCode);
+                this.optionsInitialized.next(true);
+            }
+        });
+    }
+}
+OptionsService.ɵprov = i0.ɵɵdefineInjectable({ factory: function OptionsService_Factory() { return new OptionsService(i0.ɵɵinject(i1.DictionaryService)); }, token: OptionsService, providedIn: "root" });
+OptionsService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+OptionsService.ctorParameters = () => [
+    { type: DictionaryService }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc2hhcmVkY29tcG9uZW50cy9zcmMvbGliL3NlcnZpY2Uvb3B0aW9ucy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBQyxlQUFlLEVBQUMsTUFBTSxNQUFNLENBQUM7QUFDckMsT0FBTyxFQUFDLGlCQUFpQixFQUFDLE1BQU0sc0JBQXNCLENBQUM7QUFDdkQsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLG1CQUFtQixDQUFDOzs7QUFLakQsTUFBTSxPQUFPLGNBQWM7SUFnQnpCLFlBQW9CLFdBQThCO1FBQTlCLGdCQUFXLEdBQVgsV0FBVyxDQUFtQjtRQWQzQyx1QkFBa0IsR0FBNkIsSUFBSSxlQUFlLENBQVUsS0FBSyxDQUFDLENBQUM7UUFVbkYsa0JBQWEsR0FBNkIsSUFBSSxlQUFlLENBQUMsS0FBSyxDQUFDLENBQUM7SUFLNUUsQ0FBQztJQWJELElBQVcsT0FBTyxDQUFDLEtBQVU7UUFDM0IsSUFBSSxDQUFDLFFBQVEsR0FBRyxLQUFLLENBQUM7SUFDeEIsQ0FBQztJQUVELElBQVcsT0FBTztRQUNoQixPQUFPLElBQUksQ0FBQyxRQUFRLENBQUM7SUFDdkIsQ0FBQztJQVNZLHdCQUF3QixDQUFDLEdBQVE7O1lBQzVDLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFO2dCQUNqQixJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksY0FBYyxFQUFFLENBQUM7YUFDckM7WUFDRCxJQUFJLENBQUMsT0FBTyxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxHQUFHLENBQUMsQ0FBQztZQUNoRCxJQUFJLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNoQyxDQUFDO0tBQUE7SUFFWSxVQUFVLENBQUMsT0FBWTs7WUFDbEMsSUFBSSxPQUFPLEVBQUU7Z0JBQ1gsTUFBTSxJQUFJLENBQUMsd0JBQXdCLENBQUMsT0FBTyxDQUFDLENBQUM7Z0JBQzdDLE1BQU0sSUFBSSxDQUFDLFdBQVcsQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxZQUFZLENBQUMsQ0FBQztnQkFDaEUsSUFBSSxDQUFDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQzthQUNwQztRQUNILENBQUM7S0FBQTs7OztZQXBDRixVQUFVLFNBQUM7Z0JBQ1YsVUFBVSxFQUFFLE1BQU07YUFDbkI7OztZQUxPLGlCQUFpQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SW5qZWN0YWJsZX0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHtCZWhhdmlvclN1YmplY3R9IGZyb20gXCJyeGpzXCI7XHJcbmltcG9ydCB7RGljdGlvbmFyeVNlcnZpY2V9IGZyb20gXCIuL2RpY3Rpb25hcnkuc2VydmljZVwiO1xyXG5pbXBvcnQge1NoYXJlZFNldHRpbmdzfSBmcm9tICcuLi9tb2RlbC9zZXR0aW5ncyc7XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogXCJyb290XCJcclxufSlcclxuZXhwb3J0IGNsYXNzIE9wdGlvbnNTZXJ2aWNlIHtcclxuXHJcbiAgcHVibGljIG9wdGlvbnNJbml0aWFsaXplZDogQmVoYXZpb3JTdWJqZWN0PGJvb2xlYW4+ID0gbmV3IEJlaGF2aW9yU3ViamVjdDxib29sZWFuPihmYWxzZSk7XHJcblxyXG4gIHB1YmxpYyBzZXQgb3B0aW9ucyh2YWx1ZTogYW55KSB7XHJcbiAgICB0aGlzLl9vcHRpb25zID0gdmFsdWU7XHJcbiAgfVxyXG5cclxuICBwdWJsaWMgZ2V0IG9wdGlvbnMoKTogYW55IHtcclxuICAgIHJldHVybiB0aGlzLl9vcHRpb25zO1xyXG4gIH1cclxuXHJcbiAgcHVibGljIG9wdGlvbnNMb2FkZWQ6IEJlaGF2aW9yU3ViamVjdDxib29sZWFuPiA9IG5ldyBCZWhhdmlvclN1YmplY3QoZmFsc2UpO1xyXG5cclxuICBwcml2YXRlIF9vcHRpb25zOiBhbnk7XHJcblxyXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgX2RpY3Rpb25hcnk6IERpY3Rpb25hcnlTZXJ2aWNlKSB7XHJcbiAgfVxyXG5cclxuICBwdWJsaWMgYXN5bmMgY3JlYXRlU2V0dGluZ3NGcm9tT2JqZWN0KG9iajogYW55KTogUHJvbWlzZTx2b2lkPiB7XHJcbiAgICBpZiAoIXRoaXMub3B0aW9ucykge1xyXG4gICAgICB0aGlzLm9wdGlvbnMgPSBuZXcgU2hhcmVkU2V0dGluZ3MoKTtcclxuICAgIH1cclxuICAgIHRoaXMub3B0aW9ucyA9IE9iamVjdC5hc3NpZ24odGhpcy5vcHRpb25zLCBvYmopO1xyXG4gICAgdGhpcy5vcHRpb25zTG9hZGVkLm5leHQodHJ1ZSk7XHJcbiAgfVxyXG5cclxuICBwdWJsaWMgYXN5bmMgaW5pdGlhbGl6ZShvcHRpb25zOiBhbnkpOiBQcm9taXNlPHZvaWQ+IHtcclxuICAgIGlmIChvcHRpb25zKSB7XHJcbiAgICAgIGF3YWl0IHRoaXMuY3JlYXRlU2V0dGluZ3NGcm9tT2JqZWN0KG9wdGlvbnMpO1xyXG4gICAgICBhd2FpdCB0aGlzLl9kaWN0aW9uYXJ5LnNldERpY3Rpb25hcnkodGhpcy5vcHRpb25zLmxhbmd1YWdlQ29kZSk7XHJcbiAgICAgIHRoaXMub3B0aW9uc0luaXRpYWxpemVkLm5leHQodHJ1ZSk7XHJcbiAgICB9XHJcbiAgfVxyXG59XHJcbiJdfQ==