@tilde-nlp/ngx-translate 1.0.0

package/esm2020/lib/modules/tld-tooltip/services/tld-system.service.mjs

@@ -0,0 +1,302 @@
+import { Inject, Injectable } from '@angular/core';
+import { BehaviorSubject, ReplaySubject } from 'rxjs';
+import { SYSTEM_SERVICE_TOKEN, TRANSLATION_API_VERSION_TOKEN } from '../../../injection-tokens';
+import { Common, TranslationApiVersion } from '../../tld-common/models';
+import * as i0 from "@angular/core";
+import * as i1 from "../../tld-common/services";
+export class TldSystemService {
+    constructor(config, api, apiVersion) {
+        this.config = config;
+        this.api = api;
+        this.apiVersion = apiVersion;
+        this.noSystemsError = false;
+        this.systems = [];
+        this.widgetInitialized = false;
+        this.sysList = new ReplaySubject(1);
+        this.domains = [];
+        this.vendors = [];
+        this.sourceLangList = [];
+        this.targetLangList = [];
+        this.recentSystems = [];
+        //#endregion
+        this.recentSystemKey = "recentSystems";
+        this.active = new BehaviorSubject(null);
+        this.lastUsedSystemKey = "lastUsedSystem";
+    }
+    get activeVendor() {
+        return this.activeSystem.vendor || this.defaultVendor;
+    }
+    get defaultVendor() {
+        return this.config.coreConfig.defaultVendor;
+    }
+    get defaultDomains() {
+        return this.config.coreConfig.defaultDomains;
+    }
+    //#region Recent system variables
+    // Possibly from config
+    get recentSystemsMaxCount() { return this.config.coreConfig.maxRecentSystemCount; }
+    ;
+    getSystems() {
+        return this.systems;
+    }
+    changeLanguage(source, target) {
+        const systemId = this.findCorrectSystem(source, target);
+        this.changeSystem(systemId);
+    }
+    getActiveData() {
+        return this.active.asObservable();
+    }
+    getActiveSystemObj() {
+        return this.activeSystem;
+    }
+    getActiveVendorsAndDomains() {
+        if (!this.sourceLanguage || !this.targetLanguage) {
+            return;
+        }
+        const vendors = [];
+        const domains = [];
+        for (const system of this.systems) {
+            if (!(system.sourceLanguage === this.sourceLanguage && system.targetLanguage === this.targetLanguage)) {
+                continue;
+            }
+            const domain = {
+                domain: system.id,
+                title: system.domain
+            };
+            domains.push(domain);
+            const vendor = {
+                systemId: system.id,
+                title: system.vendor
+            };
+            if (!vendors.includes(vendor)) {
+                vendors.push(vendor);
+            }
+            if (domain.domain === this.activeSystem.id) {
+                this.activeDomain = domain;
+            }
+        }
+        this.domains = domains;
+        this.vendors = vendors;
+    }
+    getLastUsedSystem() {
+        return localStorage.getItem(this.lastUsedSystemKey);
+    }
+    getUniqueLanguages(list) {
+        if (!list) {
+            return [];
+        }
+        const titles = [];
+        list.forEach((lang) => {
+            const langTitle = lang.lang;
+            const ix = titles.indexOf(langTitle);
+            if (ix == -1) {
+                titles.push(langTitle);
+            }
+        });
+        return titles;
+    }
+    init(defaultSystemId) {
+        this.api.getSystemList().subscribe((res) => {
+            this.systems = res;
+            if (res.length == 0) {
+                this.noSystemsError = true;
+            }
+            if (!this.systemExists(defaultSystemId, this.systems)) {
+                defaultSystemId = this.systems[0].id;
+                for (let system of this.systems) {
+                    const vendor = system.vendor;
+                    if (vendor === this.defaultVendor) {
+                        defaultSystemId = system.id;
+                        break;
+                    }
+                }
+            }
+            this.createRecentSystemArray();
+            this.sourceLangList = this.createLangList(this.systems);
+            this.changeSystem(defaultSystemId);
+            this.widgetInitialized = true;
+            this.sysList.next(this.systems);
+        });
+    }
+    setLastUsedSystem(systemId) {
+        return localStorage.setItem(this.lastUsedSystemKey, systemId);
+    }
+    swapSystemLanguages() {
+        this.changeLanguage(this.targetLanguage, this.sourceLanguage);
+    }
+    changeSystem(systemId, retranslate = true) {
+        if (this.activeSystem?.id === systemId) {
+            return;
+        }
+        let selectedSystem;
+        for (const system of this.systems) {
+            if (system.id === systemId) {
+                selectedSystem = system;
+                break;
+            }
+        }
+        this.targetLangList = this.createLangList(this.systems, selectedSystem.sourceLanguage);
+        this.targetLanguage = selectedSystem.targetLanguage;
+        this.sourceLanguage = selectedSystem.sourceLanguage;
+        this.activeSystem = selectedSystem;
+        this.getActiveVendorsAndDomains();
+        this.onActiveSystemChange(retranslate);
+        this.setLastUsedSystem(selectedSystem.id);
+    }
+    systemExists(systemId, systemList) {
+        const systems = systemList ?? this.systems;
+        for (let system of systems) {
+            if (system.id === systemId) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isTerminologySupported(system) {
+        return system.includesTerminology;
+    }
+    changeSourceLanguage(sourceLanguageCode) {
+        if (sourceLanguageCode === this.activeSystem.targetLanguage) {
+            this.changeLanguage(sourceLanguageCode, this.activeSystem.sourceLanguage);
+        }
+        else {
+            this.changeLanguage(sourceLanguageCode, this.activeSystem.targetLanguage);
+        }
+    }
+    changeTargetLanguage(targetLanguageCode) {
+        if (targetLanguageCode === this.activeSystem.sourceLanguage) {
+            this.changeLanguage(this.activeSystem.targetLanguage, targetLanguageCode);
+        }
+        else {
+            this.changeLanguage(this.activeSystem.sourceLanguage, targetLanguageCode);
+        }
+    }
+    createRecentSystemArray() {
+        let systemIdArray;
+        const recentSystemArray = [];
+        try {
+            systemIdArray = JSON.parse(localStorage.getItem(this.recentSystemKey) ?? "[]");
+        }
+        catch {
+            return;
+        }
+        systemIdArray.forEach((id) => {
+            const existingSystem = this.systems.find(system => system.id === id);
+            if (existingSystem && !this.recentSystems.includes(existingSystem)) {
+                recentSystemArray.push(existingSystem);
+            }
+        });
+        this.recentSystems = recentSystemArray;
+    }
+    addToRecentSystemArray(system) {
+        const existingSystem = this.recentSystems.find(existing => existing.id === system.id);
+        // if system already in list, put it to first position. If ix 0, no action required since latest system is already first.
+        if (existingSystem) {
+            const systemIxInRecentList = this.recentSystems.indexOf(existingSystem);
+            if (systemIxInRecentList > 0) {
+                this.recentSystems.splice(systemIxInRecentList, 1);
+                this.recentSystems.splice(0, 0, system);
+            }
+        }
+        else {
+            // if list too long, remove last (oldest element)
+            while (this.recentSystems.length >= this.recentSystemsMaxCount) {
+                this.recentSystems.pop();
+            }
+            this.recentSystems.splice(0, 0, system);
+        }
+        localStorage.setItem(this.recentSystemKey, JSON.stringify(this.recentSystems.map(system => system.id)));
+    }
+    canSwapSystemLanguages() {
+        let langSwapActive = false;
+        for (const element of this.systems) {
+            const system = element;
+            if (system.sourceLanguage == this.targetLanguage && system.targetLanguage == this.sourceLanguage) {
+                langSwapActive = true;
+                break;
+            }
+        }
+        this.canSwapLanguages = langSwapActive;
+        return langSwapActive;
+    }
+    createLangList(systems, srcLangCode) {
+        const langListItemArray = [];
+        systems.forEach((system) => {
+            if (!srcLangCode || srcLangCode === system.sourceLanguage) {
+                langListItemArray.push({
+                    domain: system.domain,
+                    lang: srcLangCode ? system.targetLanguage : system.sourceLanguage,
+                    systemId: system.id,
+                    vendor: system.vendor
+                });
+            }
+        });
+        return langListItemArray;
+    }
+    findCorrectSystem(sourceLanguage, targetLanguage) {
+        const systems = this.systems;
+        const systemsForLanguagePair = systems.filter(system => system.sourceLanguage === sourceLanguage && targetLanguage === system.targetLanguage);
+        // Ideally this case should not happen, but it is possible.
+        if (systemsForLanguagePair.length === 0) {
+            return this.systems.find(system => system.sourceLanguage === sourceLanguage)?.id;
+        }
+        let systemsWithDefaultVendor = systemsForLanguagePair.filter(system => (system.vendor || this.defaultVendor) === this.defaultVendor);
+        if (systemsWithDefaultVendor.length === 0) {
+            systemsWithDefaultVendor = systemsForLanguagePair;
+        }
+        let systemsWithDefaultDomain = systemsWithDefaultVendor.filter(system => this.defaultDomains.includes(system.domain));
+        if (systemsWithDefaultDomain.length === 0) {
+            systemsWithDefaultDomain = systemsWithDefaultVendor;
+        }
+        Common.sortByArray(systemsWithDefaultDomain, this.defaultDomains, "domain");
+        // V2 does not provide any info about statuses
+        if (this.apiVersion === TranslationApiVersion.V1) {
+            const preferredStatuses = ['running', 'queuingtransl', 'standby'];
+            Common.sortByArray(systemsWithDefaultVendor, preferredStatuses, "status");
+        }
+        return systemsWithDefaultDomain[0].id;
+    }
+    onActiveSystemChange(retranslate = true) {
+        const system = this.activeSystem;
+        this.addToRecentSystemArray(system);
+        const vendor = this.activeSystem.vendor;
+        this.active.next({
+            sourceLang: {
+                lang: this.sourceLanguage,
+                domain: system.domain,
+                vendor: vendor,
+                systemId: system.id,
+            },
+            sourceLangList: this.sourceLangList,
+            systemId: system.id,
+            targetLang: {
+                domain: system.domain,
+                vendor: vendor,
+                systemId: system.id,
+                lang: this.targetLanguage
+            },
+            targetLangList: this.targetLangList,
+            vendors: this.vendors,
+            domains: { active: this.activeDomain, domains: this.domains },
+            swapLangActive: this.canSwapSystemLanguages(),
+            system: system,
+            retranslate: retranslate,
+            recentSystems: this.recentSystems
+        });
+    }
+}
+TldSystemService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldSystemService, deps: [{ token: i1.TldTranslateConfigService }, { token: SYSTEM_SERVICE_TOKEN }, { token: TRANSLATION_API_VERSION_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+TldSystemService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldSystemService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldSystemService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TldTranslateConfigService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SYSTEM_SERVICE_TOKEN]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TRANSLATION_API_VERSION_TOKEN]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tld-system.service.js","sourceRoot":"","sources":["../../../../../../../projects/tld-translate/src/lib/modules/tld-tooltip/services/tld-system.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,6BAA6B,EAAE,MAAM,2BAA2B,CAAC;AAChG,OAAO,EAAE,MAAM,EAAuC,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;;;AAU7G,MAAM,OAAO,gBAAgB;IAsC3B,YAA6B,MAAiC,EACb,GAAyB,EAChB,UAAU;QAFvC,WAAM,GAAN,MAAM,CAA2B;QACb,QAAG,GAAH,GAAG,CAAsB;QAChB,eAAU,GAAV,UAAU,CAAA;QAvCpE,mBAAc,GAAG,KAAK,CAAC;QACvB,YAAO,GAAa,EAAE,CAAC;QACvB,sBAAiB,GAAG,KAAK,CAAC;QAC1B,YAAO,GAAG,IAAI,aAAa,CAAW,CAAC,CAAC,CAAC;QAiBjC,YAAO,GAAc,EAAE,CAAC;QACxB,YAAO,GAAc,EAAE,CAAC;QAGxB,mBAAc,GAAoB,EAAE,CAAC;QACrC,mBAAc,GAAoB,EAAE,CAAC;QAKrC,kBAAa,GAAa,EAAE,CAAC;QACrC,YAAY;QAEK,oBAAe,GAAG,eAAe,CAAC;QAClC,WAAM,GAAiC,IAAI,eAAe,CAAc,IAAI,CAAC,CAAC;QAC9E,sBAAiB,GAAW,gBAAgB,CAAC;IAK9D,CAAC;IAjCD,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,IAAI,IAAI,CAAC,aAAa,CAAC;IACxD,CAAC;IAED,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,aAAa,CAAC;IAC9C,CAAC;IAED,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,cAAc,CAAC;IAC/C,CAAC;IAUD,iCAAiC;IACjC,uBAAuB;IACvB,IAAI,qBAAqB,KAAK,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAC,CAAC;IAAA,CAAC;IAapF,UAAU;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,cAAc,CAAC,MAAc,EAAE,MAAc;QAC3C,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACxD,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;IAC9B,CAAC;IAED,aAAa;QACX,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;IACpC,CAAC;IAED,kBAAkB;QAChB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,0BAA0B;QACxB,IAAI,CAAC,IAAI,CAAC,cAAc,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE;YAChD,OAAO;SACR;QACD,MAAM,OAAO,GAAc,EAAE,CAAC;QAC9B,MAAM,OAAO,GAAc,EAAE,CAAC;QAE9B,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE;YACjC,IAAI,CAAC,CAAC,MAAM,CAAC,cAAc,KAAK,IAAI,CAAC,cAAc,IAAI,MAAM,CAAC,cAAc,KAAK,IAAI,CAAC,cAAc,CAAC,EAAE;gBACrG,SAAS;aACV;YACD,MAAM,MAAM,GAAY;gBACtB,MAAM,EAAE,MAAM,CAAC,EAAE;gBACjB,KAAK,EAAE,MAAM,CAAC,MAAM;aACrB,CAAC;YACF,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACrB,MAAM,MAAM,GAAY;gBACtB,QAAQ,EAAE,MAAM,CAAC,EAAE;gBACnB,KAAK,EAAE,MAAM,CAAC,MAAM;aACrB,CAAA;YAED,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;gBAC7B,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aACtB;YAED,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,CAAC,YAAY,CAAC,EAAE,EAAE;gBAC1C,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC;aAC5B;SACF;QAED,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAGD,iBAAiB;QACf,OAAO,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;IACtD,CAAC;IAED,kBAAkB,CAAC,IAAqB;QACtC,IAAI,CAAC,IAAI,EAAE;YACT,OAAO,EAAE,CAAC;SACX;QACD,MAAM,MAAM,GAAa,EAAE,CAAC;QAE5B,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YACpB,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC;YAC5B,MAAM,EAAE,GAAG,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YACrC,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE;gBACZ,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;aACxB;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,IAAI,CAAC,eAAuB;QAC1B,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC,SAAS,CAAC,CAAC,GAAa,EAAE,EAAE;YACnD,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC;YACnB,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,EAAE;gBACnB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;aAC5B;YAED,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE;gBACrD,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;gBACrC,KAAK,IAAI,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE;oBAC/B,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;oBAC7B,IAAI,MAAM,KAAK,IAAI,CAAC,aAAa,EAAE;wBACjC,eAAe,GAAG,MAAM,CAAC,EAAE,CAAC;wBAC5B,MAAM;qBACP;iBACF;aACF;YAED,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAC/B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACxD,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC;YACnC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;YAC9B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAClC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,iBAAiB,CAAC,QAAgB;QAChC,OAAO,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,EAAE,QAAQ,CAAC,CAAC;IAChE,CAAC;IAED,mBAAmB;QACjB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;IAChE,CAAC;IAED,YAAY,CAAC,QAAgB,EAAE,WAAW,GAAG,IAAI;QAC/C,IAAI,IAAI,CAAC,YAAY,EAAE,EAAE,KAAK,QAAQ,EAAE;YACtC,OAAO;SACR;QAED,IAAI,cAAsB,CAAC;QAC3B,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE;YACjC,IAAI,MAAM,CAAC,EAAE,KAAK,QAAQ,EAAE;gBAC1B,cAAc,GAAG,MAAM,CAAC;gBACxB,MAAM;aACP;SACF;QACD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,cAAc,CAAC,CAAC;QACvF,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC,cAAc,CAAC;QACpD,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC,cAAc,CAAC;QACpD,IAAI,CAAC,YAAY,GAAG,cAAc,CAAC;QACnC,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAElC,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC;QAEvC,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED,YAAY,CAAC,QAAgB,EAAE,UAAoB;QACjD,MAAM,OAAO,GAAG,UAAU,IAAI,IAAI,CAAC,OAAO,CAAC;QAC3C,KAAK,IAAI,MAAM,IAAI,OAAO,EAAE;YAC1B,IAAI,MAAM,CAAC,EAAE,KAAK,QAAQ,EAAE;gBAC1B,OAAO,IAAI,CAAC;aACb;SACF;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED,sBAAsB,CAAC,MAAc;QACnC,OAAO,MAAM,CAAC,mBAAmB,CAAC;IACpC,CAAC;IAED,oBAAoB,CAAC,kBAA0B;QAC7C,IAAI,kBAAkB,KAAK,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE;YAC3D,IAAI,CAAC,cAAc,CAAC,kBAAkB,EAAE,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;SAC3E;aACI;YACH,IAAI,CAAC,cAAc,CAAC,kBAAkB,EAAE,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;SAC3E;IAEH,CAAC;IAED,oBAAoB,CAAC,kBAA0B;QAC7C,IAAI,kBAAkB,KAAK,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE;YAC3D,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,kBAAkB,CAAC,CAAC;SAC3E;aACI;YACH,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,kBAAkB,CAAC,CAAC;SAC3E;IACH,CAAC;IAEO,uBAAuB;QAC7B,IAAI,aAAuB,CAAC;QAC5B,MAAM,iBAAiB,GAAa,EAAE,CAAC;QACvC,IAAI;YACF,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,IAAI,CAAC,CAAC;SAChF;QACD,MAAM;YACJ,OAAO;SACR;QACD,aAAa,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE;YAC3B,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;YACrE,IAAI,cAAc,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE;gBAClE,iBAAiB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;aACxC;QACH,CAAC,CAAC,CAAA;QACF,IAAI,CAAC,aAAa,GAAG,iBAAiB,CAAC;IACzC,CAAC;IAEO,sBAAsB,CAAC,MAAc;QAC3C,MAAM,cAAc,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,KAAK,MAAM,CAAC,EAAE,CAAC,CAAC;QACtF,yHAAyH;QACzH,IAAI,cAAc,EAAE;YAClB,MAAM,oBAAoB,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;YACxE,IAAI,oBAAoB,GAAG,CAAC,EAAE;gBAC5B,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,oBAAoB,EAAE,CAAC,CAAC,CAAC;gBACnD,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;aACzC;SACF;aACI;YACH,iDAAiD;YACjD,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,IAAI,IAAI,CAAC,qBAAqB,EAAE;gBAC9D,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC;aAC1B;YAED,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;SACzC;QACD,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC1G,CAAC;IAEO,sBAAsB;QAC5B,IAAI,cAAc,GAAG,KAAK,CAAC;QAC3B,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,OAAO,EAAE;YAClC,MAAM,MAAM,GAAG,OAAO,CAAC;YACvB,IAAI,MAAM,CAAC,cAAc,IAAI,IAAI,CAAC,cAAc,IAAI,MAAM,CAAC,cAAc,IAAI,IAAI,CAAC,cAAc,EAAE;gBAChG,cAAc,GAAG,IAAI,CAAC;gBACtB,MAAM;aACP;SACF;QACD,IAAI,CAAC,gBAAgB,GAAG,cAAc,CAAC;QACvC,OAAO,cAAc,CAAC;IACxB,CAAC;IAEO,cAAc,CAAC,OAAiB,EAAE,WAAoB;QAC5D,MAAM,iBAAiB,GAAoB,EAAE,CAAC;QAC9C,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YACzB,IAAI,CAAC,WAAW,IAAI,WAAW,KAAK,MAAM,CAAC,cAAc,EAAE;gBACzD,iBAAiB,CAAC,IAAI,CACpB;oBACE,MAAM,EAAE,MAAM,CAAC,MAAM;oBACrB,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC,cAAc;oBACjE,QAAQ,EAAE,MAAM,CAAC,EAAE;oBACnB,MAAM,EAAE,MAAM,CAAC,MAAM;iBACtB,CACF,CAAC;aACH;QACH,CAAC,CAAC,CAAA;QACF,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAEO,iBAAiB,CAAC,cAAsB,EAAE,cAAsB;QACtE,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAE7B,MAAM,sBAAsB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,cAAc,KAAK,cAAc,IAAI,cAAc,KAAK,MAAM,CAAC,cAAc,CAAC,CAAC;QAC9I,2DAA2D;QAC3D,IAAI,sBAAsB,CAAC,MAAM,KAAK,CAAC,EAAE;YACvC,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,cAAc,KAAK,cAAc,CAAC,EAAE,EAAE,CAAC;SAClF;QAED,IAAI,wBAAwB,GAAG,sBAAsB,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC,aAAa,CAAC,CAAC;QACrI,IAAI,wBAAwB,CAAC,MAAM,KAAK,CAAC,EAAE;YACzC,wBAAwB,GAAG,sBAAsB,CAAC;SACnD;QAED,IAAI,wBAAwB,GAAG,wBAAwB,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;QACtH,IAAI,wBAAwB,CAAC,MAAM,KAAK,CAAC,EAAE;YACzC,wBAAwB,GAAG,wBAAwB,CAAC;SACrD;QACD,MAAM,CAAC,WAAW,CAAC,wBAAwB,EAAE,IAAI,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;QAG5E,8CAA8C;QAC9C,IAAI,IAAI,CAAC,UAAU,KAAK,qBAAqB,CAAC,EAAE,EAAE;YAChD,MAAM,iBAAiB,GAAG,CAAC,SAAS,EAAE,eAAe,EAAE,SAAS,CAAC,CAAC;YAClE,MAAM,CAAC,WAAW,CAAC,wBAAwB,EAAE,iBAAiB,EAAE,QAAQ,CAAC,CAAC;SAC3E;QAED,OAAO,wBAAwB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACxC,CAAC;IAEO,oBAAoB,CAAC,WAAW,GAAG,IAAI;QAC7C,MAAM,MAAM,GAAW,IAAI,CAAC,YAAY,CAAC;QACzC,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC;QACpC,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC;QACxC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;YACf,UAAU,EAAE;gBACV,IAAI,EAAE,IAAI,CAAC,cAAc;gBACzB,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,MAAM,EAAE,MAAM;gBACd,QAAQ,EAAE,MAAM,CAAC,EAAE;aACpB;YACD,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,QAAQ,EAAE,MAAM,CAAC,EAAE;YACnB,UAAU,EAAE;gBACV,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,MAAM,EAAE,MAAM;gBACd,QAAQ,EAAE,MAAM,CAAC,EAAE;gBACnB,IAAI,EAAE,IAAI,CAAC,cAAc;aAC1B;YACD,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,OAAO,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE;YAC7D,cAAc,EAAE,IAAI,CAAC,sBAAsB,EAAE;YAC7C,MAAM,EAAE,MAAM;YACd,WAAW,EAAE,WAAW;YACxB,aAAa,EAAE,IAAI,CAAC,aAAa;SAClC,CAAC,CAAC;IACL,CAAC;;6GA7UU,gBAAgB,2DAuCjB,oBAAoB,aACpB,6BAA6B;iHAxC5B,gBAAgB,cAFf,MAAM;2FAEP,gBAAgB;kBAH5B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAwCI,MAAM;2BAAC,oBAAoB;;0BAC3B,MAAM;2BAAC,6BAA6B","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { BehaviorSubject, ReplaySubject } from 'rxjs';\r\nimport { SYSTEM_SERVICE_TOKEN, TRANSLATION_API_VERSION_TOKEN } from '../../../injection-tokens';\r\nimport { Common, ILangListItem, ITldSystemApiService, TranslationApiVersion } from '../../tld-common/models';\r\nimport { System } from '../../tld-common/models/services/system/system.model';\r\nimport { TldTranslateConfigService } from '../../tld-common/services';\r\nimport { IActiveData } from '../models/active-data.model';\r\nimport { IDomain } from '../models/domain.model';\r\nimport { IVendor } from '../models/vendor.model';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class TldSystemService {\r\n  noSystemsError = false;\r\n  systems: System[] = [];\r\n  widgetInitialized = false;\r\n  sysList = new ReplaySubject<System[]>(1);\r\n  activeDomain: IDomain;\r\n  canSwapLanguages: boolean;\r\n\r\n  get activeVendor() {\r\n    return this.activeSystem.vendor || this.defaultVendor;\r\n  }\r\n\r\n  get defaultVendor() {\r\n    return this.config.coreConfig.defaultVendor;\r\n  }\r\n\r\n  get defaultDomains() {\r\n    return this.config.coreConfig.defaultDomains;\r\n  }\r\n\r\n  private activeSystem: System;\r\n  private domains: IDomain[] = [];\r\n  private vendors: IVendor[] = [];\r\n  private sourceLanguage: string;\r\n  private targetLanguage: string;\r\n  private sourceLangList: ILangListItem[] = [];\r\n  private targetLangList: ILangListItem[] = [];\r\n\r\n  //#region Recent system variables\r\n  // Possibly from config\r\n  get recentSystemsMaxCount() { return this.config.coreConfig.maxRecentSystemCount; };\r\n  private recentSystems: System[] = [];\r\n  //#endregion\r\n\r\n  private readonly recentSystemKey = \"recentSystems\";\r\n  private readonly active: BehaviorSubject<IActiveData> = new BehaviorSubject<IActiveData>(null);\r\n  private readonly lastUsedSystemKey: string = \"lastUsedSystem\";\r\n\r\n  constructor(private readonly config: TldTranslateConfigService,\r\n    @Inject(SYSTEM_SERVICE_TOKEN) private readonly api: ITldSystemApiService,\r\n    @Inject(TRANSLATION_API_VERSION_TOKEN) private readonly apiVersion) {\r\n  }\r\n\r\n  getSystems(): System[] {\r\n    return this.systems;\r\n  }\r\n\r\n  changeLanguage(source: string, target: string) {\r\n    const systemId = this.findCorrectSystem(source, target);\r\n    this.changeSystem(systemId);\r\n  }\r\n\r\n  getActiveData() {\r\n    return this.active.asObservable();\r\n  }\r\n\r\n  getActiveSystemObj(): System {\r\n    return this.activeSystem;\r\n  }\r\n\r\n  getActiveVendorsAndDomains() {\r\n    if (!this.sourceLanguage || !this.targetLanguage) {\r\n      return;\r\n    }\r\n    const vendors: IVendor[] = [];\r\n    const domains: IDomain[] = [];\r\n\r\n    for (const system of this.systems) {\r\n      if (!(system.sourceLanguage === this.sourceLanguage && system.targetLanguage === this.targetLanguage)) {\r\n        continue;\r\n      }\r\n      const domain: IDomain = {\r\n        domain: system.id,\r\n        title: system.domain\r\n      };\r\n      domains.push(domain);\r\n      const vendor: IVendor = {\r\n        systemId: system.id,\r\n        title: system.vendor\r\n      }\r\n\r\n      if (!vendors.includes(vendor)) {\r\n        vendors.push(vendor);\r\n      }\r\n\r\n      if (domain.domain === this.activeSystem.id) {\r\n        this.activeDomain = domain;\r\n      }\r\n    }\r\n\r\n    this.domains = domains;\r\n    this.vendors = vendors;\r\n  }\r\n\r\n\r\n  getLastUsedSystem(): string {\r\n    return localStorage.getItem(this.lastUsedSystemKey);\r\n  }\r\n\r\n  getUniqueLanguages(list: ILangListItem[]): string[] {\r\n    if (!list) {\r\n      return [];\r\n    }\r\n    const titles: string[] = [];\r\n\r\n    list.forEach((lang) => {\r\n      const langTitle = lang.lang;\r\n      const ix = titles.indexOf(langTitle);\r\n      if (ix == -1) {\r\n        titles.push(langTitle);\r\n      }\r\n    });\r\n\r\n    return titles;\r\n  }\r\n\r\n  init(defaultSystemId: string) {\r\n    this.api.getSystemList().subscribe((res: System[]) => {\r\n      this.systems = res;\r\n      if (res.length == 0) {\r\n        this.noSystemsError = true;\r\n      }\r\n\r\n      if (!this.systemExists(defaultSystemId, this.systems)) {\r\n        defaultSystemId = this.systems[0].id;\r\n        for (let system of this.systems) {\r\n          const vendor = system.vendor;\r\n          if (vendor === this.defaultVendor) {\r\n            defaultSystemId = system.id;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      this.createRecentSystemArray();\r\n      this.sourceLangList = this.createLangList(this.systems);\r\n      this.changeSystem(defaultSystemId);\r\n      this.widgetInitialized = true;\r\n      this.sysList.next(this.systems);\r\n    });\r\n  }\r\n\r\n  setLastUsedSystem(systemId: string) {\r\n    return localStorage.setItem(this.lastUsedSystemKey, systemId);\r\n  }\r\n\r\n  swapSystemLanguages() {\r\n    this.changeLanguage(this.targetLanguage, this.sourceLanguage);\r\n  }\r\n\r\n  changeSystem(systemId: string, retranslate = true) {\r\n    if (this.activeSystem?.id === systemId) {\r\n      return;\r\n    }\r\n\r\n    let selectedSystem: System;\r\n    for (const system of this.systems) {\r\n      if (system.id === systemId) {\r\n        selectedSystem = system;\r\n        break;\r\n      }\r\n    }\r\n    this.targetLangList = this.createLangList(this.systems, selectedSystem.sourceLanguage);\r\n    this.targetLanguage = selectedSystem.targetLanguage;\r\n    this.sourceLanguage = selectedSystem.sourceLanguage;\r\n    this.activeSystem = selectedSystem;\r\n    this.getActiveVendorsAndDomains();\r\n\r\n    this.onActiveSystemChange(retranslate);\r\n\r\n    this.setLastUsedSystem(selectedSystem.id);\r\n  }\r\n\r\n  systemExists(systemId: string, systemList: System[]): boolean {\r\n    const systems = systemList ?? this.systems;\r\n    for (let system of systems) {\r\n      if (system.id === systemId) {\r\n        return true;\r\n      }\r\n    }\r\n\r\n    return false;\r\n  }\r\n\r\n  isTerminologySupported(system: System): boolean {\r\n    return system.includesTerminology;\r\n  }\r\n\r\n  changeSourceLanguage(sourceLanguageCode: string) {\r\n    if (sourceLanguageCode === this.activeSystem.targetLanguage) {\r\n      this.changeLanguage(sourceLanguageCode, this.activeSystem.sourceLanguage);\r\n    }\r\n    else {\r\n      this.changeLanguage(sourceLanguageCode, this.activeSystem.targetLanguage);\r\n    }\r\n\r\n  }\r\n\r\n  changeTargetLanguage(targetLanguageCode: string) {\r\n    if (targetLanguageCode === this.activeSystem.sourceLanguage) {\r\n      this.changeLanguage(this.activeSystem.targetLanguage, targetLanguageCode);\r\n    }\r\n    else {\r\n      this.changeLanguage(this.activeSystem.sourceLanguage, targetLanguageCode);\r\n    }\r\n  }\r\n\r\n  private createRecentSystemArray() {\r\n    let systemIdArray: string[];\r\n    const recentSystemArray: System[] = [];\r\n    try {\r\n      systemIdArray = JSON.parse(localStorage.getItem(this.recentSystemKey) ?? \"[]\");\r\n    }\r\n    catch {\r\n      return;\r\n    }\r\n    systemIdArray.forEach((id) => {\r\n      const existingSystem = this.systems.find(system => system.id === id);\r\n      if (existingSystem && !this.recentSystems.includes(existingSystem)) {\r\n        recentSystemArray.push(existingSystem);\r\n      }\r\n    })\r\n    this.recentSystems = recentSystemArray;\r\n  }\r\n\r\n  private addToRecentSystemArray(system: System) {\r\n    const existingSystem = this.recentSystems.find(existing => existing.id === system.id);\r\n    // if system already in list, put it to first position. If ix 0, no action required since latest system is already first.\r\n    if (existingSystem) {\r\n      const systemIxInRecentList = this.recentSystems.indexOf(existingSystem);\r\n      if (systemIxInRecentList > 0) {\r\n        this.recentSystems.splice(systemIxInRecentList, 1);\r\n        this.recentSystems.splice(0, 0, system);\r\n      }\r\n    }\r\n    else {\r\n      // if list too long, remove last (oldest element)\r\n      while (this.recentSystems.length >= this.recentSystemsMaxCount) {\r\n        this.recentSystems.pop();\r\n      }\r\n\r\n      this.recentSystems.splice(0, 0, system);\r\n    }\r\n    localStorage.setItem(this.recentSystemKey, JSON.stringify(this.recentSystems.map(system => system.id)));\r\n  }\r\n\r\n  private canSwapSystemLanguages(): boolean {\r\n    let langSwapActive = false;\r\n    for (const element of this.systems) {\r\n      const system = element;\r\n      if (system.sourceLanguage == this.targetLanguage && system.targetLanguage == this.sourceLanguage) {\r\n        langSwapActive = true;\r\n        break;\r\n      }\r\n    }\r\n    this.canSwapLanguages = langSwapActive;\r\n    return langSwapActive;\r\n  }\r\n\r\n  private createLangList(systems: System[], srcLangCode?: string) {\r\n    const langListItemArray: ILangListItem[] = [];\r\n    systems.forEach((system) => {\r\n      if (!srcLangCode || srcLangCode === system.sourceLanguage) {\r\n        langListItemArray.push(\r\n          {\r\n            domain: system.domain,\r\n            lang: srcLangCode ? system.targetLanguage : system.sourceLanguage,\r\n            systemId: system.id,\r\n            vendor: system.vendor\r\n          }\r\n        );\r\n      }\r\n    })\r\n    return langListItemArray;\r\n  }\r\n\r\n  private findCorrectSystem(sourceLanguage: string, targetLanguage: string): string {\r\n    const systems = this.systems;\r\n\r\n    const systemsForLanguagePair = systems.filter(system => system.sourceLanguage === sourceLanguage && targetLanguage === system.targetLanguage);\r\n    // Ideally this case should not happen, but it is possible.\r\n    if (systemsForLanguagePair.length === 0) {\r\n      return this.systems.find(system => system.sourceLanguage === sourceLanguage)?.id;\r\n    }\r\n\r\n    let systemsWithDefaultVendor = systemsForLanguagePair.filter(system => (system.vendor || this.defaultVendor) === this.defaultVendor);\r\n    if (systemsWithDefaultVendor.length === 0) {\r\n      systemsWithDefaultVendor = systemsForLanguagePair;\r\n    }\r\n\r\n    let systemsWithDefaultDomain = systemsWithDefaultVendor.filter(system => this.defaultDomains.includes(system.domain));\r\n    if (systemsWithDefaultDomain.length === 0) {\r\n      systemsWithDefaultDomain = systemsWithDefaultVendor;\r\n    }\r\n    Common.sortByArray(systemsWithDefaultDomain, this.defaultDomains, \"domain\");\r\n\r\n\r\n    // V2 does not provide any info about statuses\r\n    if (this.apiVersion === TranslationApiVersion.V1) {\r\n      const preferredStatuses = ['running', 'queuingtransl', 'standby'];\r\n      Common.sortByArray(systemsWithDefaultVendor, preferredStatuses, \"status\");\r\n    }\r\n\r\n    return systemsWithDefaultDomain[0].id;\r\n  }\r\n\r\n  private onActiveSystemChange(retranslate = true) {\r\n    const system: System = this.activeSystem;\r\n    this.addToRecentSystemArray(system);\r\n    const vendor = this.activeSystem.vendor;\r\n    this.active.next({\r\n      sourceLang: {\r\n        lang: this.sourceLanguage,\r\n        domain: system.domain,\r\n        vendor: vendor,\r\n        systemId: system.id,\r\n      },\r\n      sourceLangList: this.sourceLangList,\r\n      systemId: system.id,\r\n      targetLang: {\r\n        domain: system.domain,\r\n        vendor: vendor,\r\n        systemId: system.id,\r\n        lang: this.targetLanguage\r\n      },\r\n      targetLangList: this.targetLangList,\r\n      vendors: this.vendors,\r\n      domains: { active: this.activeDomain, domains: this.domains },\r\n      swapLangActive: this.canSwapSystemLanguages(),\r\n      system: system,\r\n      retranslate: retranslate,\r\n      recentSystems: this.recentSystems\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2020/lib/modules/tld-tooltip/tld-domain-list/tld-domain-list.component.mjs

@@ -0,0 +1,69 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { TranslateDomainPipe } from '../../tld-common/pipes/translate-domain.pipe';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "../../tld-common/services/tld-translate-config.service";
+import * as i3 from "../../tld-common/pipes/translate-domain.pipe";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/flex-layout/extended";
+import * as i6 from "../../tld-common/components/tld-list-menu/tld-list-menu.component";
+import * as i7 from "@tilde-nlp/ngx-common";
+export class TldDomainListComponent {
+    constructor(translate, config, translateDomainPipe) {
+        this.translate = translate;
+        this.config = config;
+        this.translateDomainPipe = translateDomainPipe;
+        this.selectionChange = new EventEmitter();
+        this.titleKey = "title";
+        this.valueKey = "domain";
+    }
+    get list() { return this._list; }
+    set list(value) {
+        this._list = value;
+        this.retranslate();
+    }
+    ;
+    get selected() { return this._selected; }
+    set selected(value) {
+        this._selected = value;
+        this.selectedDomainName = this.translateDomainName(value?.title);
+    }
+    ;
+    get showTitle() { return this.config.coreConfig.showDomainTitle; }
+    ngOnInit() {
+        this.translate.stream("DOMAINS").subscribe((translations) => {
+            this.translations = translations;
+            this.retranslate();
+            this.currentLanguage = this.translate.currentLang;
+        });
+    }
+    select(element) {
+        this.selectionChange.next(element);
+    }
+    retranslate() {
+        this.selectedDomainName = this.translateDomainName(this.selected?.title);
+        const translatedList = [];
+        this.list.forEach((domain) => {
+            translatedList.push({ title: this.translateDomainName(domain.title), domain: domain.domain });
+        });
+        this.translatedList = translatedList;
+    }
+    translateDomainName(domainName) {
+        return this.translateDomainPipe.transform(domainName);
+    }
+}
+TldDomainListComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldDomainListComponent, deps: [{ token: i1.TranslateService }, { token: i2.TldTranslateConfigService }, { token: i3.TranslateDomainPipe }], target: i0.ɵɵFactoryTarget.Component });
+TldDomainListComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: TldDomainListComponent, selector: "tld-domain-list", inputs: { list: "list", selected: "selected", disabled: "disabled" }, outputs: { selectionChange: "selectionChange" }, providers: [TranslateDomainPipe], ngImport: i0, template: "<span fxHide.lt-md class=\"domain-title\" *ngIf=\"showTitle\">{{'DOMAINS.TITLE' | translate}}</span>\r\n<tld-list-menu (selectionChange)=\"select($event)\" [list]=\"translatedList | sortTranslations: null: 'title': currentLanguage | async\" [titleKey]=\"titleKey\" \r\n[valueKey]=\"valueKey\" testId=\"tld-domain-list\" [disabled]=\"disabled\" [ariaLabel]=\"'DOMAINS.OPEN_LIST_ARIA_LABEL' | translate\">\r\n    {{selectedDomainName | titlecase}}\r\n</tld-list-menu>", styles: [""], dependencies: [{ kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i5.DefaultShowHideDirective, selector: "  [fxShow], [fxShow.print],  [fxShow.xs], [fxShow.sm], [fxShow.md], [fxShow.lg], [fxShow.xl],  [fxShow.lt-sm], [fxShow.lt-md], [fxShow.lt-lg], [fxShow.lt-xl],  [fxShow.gt-xs], [fxShow.gt-sm], [fxShow.gt-md], [fxShow.gt-lg],  [fxHide], [fxHide.print],  [fxHide.xs], [fxHide.sm], [fxHide.md], [fxHide.lg], [fxHide.xl],  [fxHide.lt-sm], [fxHide.lt-md], [fxHide.lt-lg], [fxHide.lt-xl],  [fxHide.gt-xs], [fxHide.gt-sm], [fxHide.gt-md], [fxHide.gt-lg]", inputs: ["fxShow", "fxShow.print", "fxShow.xs", "fxShow.sm", "fxShow.md", "fxShow.lg", "fxShow.xl", "fxShow.lt-sm", "fxShow.lt-md", "fxShow.lt-lg", "fxShow.lt-xl", "fxShow.gt-xs", "fxShow.gt-sm", "fxShow.gt-md", "fxShow.gt-lg", "fxHide", "fxHide.print", "fxHide.xs", "fxHide.sm", "fxHide.md", "fxHide.lg", "fxHide.xl", "fxHide.lt-sm", "fxHide.lt-md", "fxHide.lt-lg", "fxHide.lt-xl", "fxHide.gt-xs", "fxHide.gt-sm", "fxHide.gt-md", "fxHide.gt-lg"] }, { kind: "component", type: i6.TldListMenuComponent, selector: "tld-list-menu", inputs: ["titleKey", "list", "showContent", "selectedValue", "disabled", "ariaLabel", "valueKey", "testId"], outputs: ["selectionChange"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.TitleCasePipe, name: "titlecase" }, { kind: "pipe", type: i1.TranslatePipe, name: "translate" }, { kind: "pipe", type: i7.SortTranslationsPipe, name: "sortTranslations" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldDomainListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tld-domain-list', providers: [TranslateDomainPipe], template: "<span fxHide.lt-md class=\"domain-title\" *ngIf=\"showTitle\">{{'DOMAINS.TITLE' | translate}}</span>\r\n<tld-list-menu (selectionChange)=\"select($event)\" [list]=\"translatedList | sortTranslations: null: 'title': currentLanguage | async\" [titleKey]=\"titleKey\" \r\n[valueKey]=\"valueKey\" testId=\"tld-domain-list\" [disabled]=\"disabled\" [ariaLabel]=\"'DOMAINS.OPEN_LIST_ARIA_LABEL' | translate\">\r\n    {{selectedDomainName | titlecase}}\r\n</tld-list-menu>" }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.TldTranslateConfigService }, { type: i3.TranslateDomainPipe }]; }, propDecorators: { list: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], selectionChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/tld-tooltip/tld-tooltip.module.mjs

@@ -0,0 +1,95 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FlexLayoutModule } from '@angular/flex-layout';
+import { FormsModule } from '@angular/forms';
+import { BrowserModule } from '@angular/platform-browser';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { TranslateModule } from '@ngx-translate/core';
+import { ClickOutsideModule, FilterWithHighlightModule, SortTranslationsModule } from '@tilde-nlp/ngx-common';
+import { MaterialModule } from '../material.module';
+import { TldCommonModule } from '../tld-common';
+import { TldTermModule } from '../tld-term';
+import { TldDomainListComponent } from './tld-domain-list/tld-domain-list.component';
+import { TldTranslateSwitcherComponent } from './tld-translate-switcher/tld-translate-switcher.component';
+import { TranslationSystemPickerButtonComponent, TranslationSystemPickerFilterComponent } from './translation-system-picker';
+import { TranslationSystemPickerDropdownBodyComponent } from './translation-system-picker/dropdown-body/translation-system-picker-dropdown-body.component';
+import { TranslationSystemPickerDropdownComponent } from './translation-system-picker/dropdown/translation-system-picker-dropdown.component';
+import { TranslationSystemPickerLanguageListComponent } from './translation-system-picker/language-list/translation-system-picker-language-list.component';
+import { TranslationSystemPickerSystemListComponent } from './translation-system-picker/system-list/translation-system-picker-system-list.component';
+import { TranslationSystemPickerComponent } from './translation-system-picker/translation-system-picker.component';
+import * as i0 from "@angular/core";
+export class TldTooltipModule {
+}
+TldTooltipModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTooltipModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TldTooltipModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: TldTooltipModule, declarations: [TldTranslateSwitcherComponent,
+        TldDomainListComponent,
+        TranslationSystemPickerComponent,
+        TranslationSystemPickerDropdownComponent,
+        TranslationSystemPickerLanguageListComponent,
+        TranslationSystemPickerSystemListComponent,
+        TranslationSystemPickerFilterComponent,
+        TranslationSystemPickerDropdownBodyComponent,
+        TranslationSystemPickerButtonComponent], imports: [FormsModule,
+        CommonModule,
+        BrowserModule,
+        FlexLayoutModule,
+        MaterialModule,
+        TranslateModule,
+        TldCommonModule,
+        TldTermModule,
+        BrowserAnimationsModule,
+        SortTranslationsModule,
+        FilterWithHighlightModule,
+        ClickOutsideModule], exports: [TldTranslateSwitcherComponent,
+        TldDomainListComponent,
+        TranslationSystemPickerComponent,
+        TranslationSystemPickerDropdownComponent] });
+TldTooltipModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTooltipModule, imports: [FormsModule,
+        CommonModule,
+        BrowserModule,
+        FlexLayoutModule,
+        MaterialModule,
+        TranslateModule,
+        TldCommonModule,
+        TldTermModule,
+        BrowserAnimationsModule,
+        SortTranslationsModule,
+        FilterWithHighlightModule,
+        ClickOutsideModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTooltipModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        TldTranslateSwitcherComponent,
+                        TldDomainListComponent,
+                        TranslationSystemPickerComponent,
+                        TranslationSystemPickerDropdownComponent,
+                        TranslationSystemPickerLanguageListComponent,
+                        TranslationSystemPickerSystemListComponent,
+                        TranslationSystemPickerFilterComponent,
+                        TranslationSystemPickerDropdownBodyComponent,
+                        TranslationSystemPickerButtonComponent
+                    ],
+                    imports: [
+                        FormsModule,
+                        CommonModule,
+                        BrowserModule,
+                        FlexLayoutModule,
+                        MaterialModule,
+                        TranslateModule,
+                        TldCommonModule,
+                        TldTermModule,
+                        BrowserAnimationsModule,
+                        SortTranslationsModule,
+                        FilterWithHighlightModule,
+                        ClickOutsideModule
+                    ],
+                    exports: [
+                        TldTranslateSwitcherComponent,
+                        TldDomainListComponent,
+                        TranslationSystemPickerComponent,
+                        TranslationSystemPickerDropdownComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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