@tilde-nlp/ngx-translate 2.0.3 → 2.1.0

package/esm2020/lib/modules/tld-term/services/terminology.service.mjs

@@ -0,0 +1,292 @@
+import { Inject, Injectable } from '@angular/core';
+import { forkJoin, Subject, tap } from 'rxjs';
+import { MT_TERM_API_TOKEN } from '../../../injection-tokens';
+import { EngineTermCollectionSource } from './engine-term/models';
+import { CombinedCollection } from './models/combined-collection.model';
+import { MtCollectionStatus } from './models/mt-collection-status.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../tld-common/services";
+import * as i2 from "./term-api/term-api.service";
+export class TerminologyService {
+    constructor(config, termApi, mtApi) {
+        this.config = config;
+        this.termApi = termApi;
+        this.mtApi = mtApi;
+        this._selected = null;
+        this.onDataUpdate = new Subject();
+        this.LOCAL_STORAGE_KEY = "systemLastCollections";
+    }
+    get selected() { return this._selected; }
+    set selected(val) {
+        this._selected = val;
+        this.storeSelectedInLocalStorage();
+        if (!this._selected) {
+            return;
+        }
+        if (!this._selected.mtCollection) {
+            this.addToEngine(this._selected);
+        }
+    }
+    get hasAnyCollections() {
+        return this._hasAnyCollections;
+    }
+    get shouldShowPromotion() {
+        return !this.hasAnyCollections && !this.hasEditPermissions;
+    }
+    get canCreateCollections() {
+        return this.config.termConfig.canCreateCollection;
+    }
+    get hasEditPermissions() {
+        return this.config?.coreConfig.isAuth && this.canCreateCollections && this.config.termConfig.isTermPortalSupported;
+    }
+    get isRefreshingCollections() {
+        return this._isRefreshingCollections;
+    }
+    get collections() {
+        return this._collections;
+    }
+    setEngine(engineId, languages = null, setSelectedFromLocalStorage = false) {
+        // engine is already set with that ID and no need to refresh it.
+        if (engineId !== this.engineId || JSON.stringify(languages) !== JSON.stringify(this.engineLanguages)) {
+            this.engineLanguages = languages;
+            this.engineId = engineId;
+            this._collections = new Set();
+            this.emitDataUpdateEvent();
+            // avoiding setter, so the null value is not storeed in location since it is not by user action
+            this._selected = null;
+        }
+        if (this.engineId) {
+            this.refreshCollections(setSelectedFromLocalStorage, true);
+        }
+        return this.onDataUpdate.asObservable();
+    }
+    refreshCollections(setSelectedFromLocalStorage = false, initialRefresh = false) {
+        if (!this.engineId || !this.config.termConfig.isCollectionsActivated || this.isRefreshingCollections) {
+            return;
+        }
+        // clear timeout since this refresh replaces scheduled
+        this.clearTimeout();
+        this._isRefreshingCollections = true;
+        let termResponse;
+        let mtApiResponse;
+        const observables = [
+            this.termApi.getCollectionList(this.engineLanguages)
+                .pipe(tap((response) => termResponse = response)),
+            this.mtApi.getList(this.engineId)
+                .pipe(tap((response) => mtApiResponse = response)),
+        ];
+        forkJoin(observables).subscribe({
+            // do not need response becaue responses are saved in pipe methods
+            next: () => {
+                this.isAnyImporting = false;
+                // note that termResponse and mtapiresponse gets changed during remove method
+                this.removeDeleted(termResponse, mtApiResponse, initialRefresh);
+                this.addCollections([...mtApiResponse, ...termResponse], initialRefresh);
+                if (setSelectedFromLocalStorage) {
+                    this.setSelectedFromLocalStorage();
+                }
+                this._isRefreshingCollections = false;
+                this.scheduleRefresh();
+            },
+            error: (error) => {
+                this._isRefreshingCollections = false;
+                // it is enough to show error only in console. No special thing is necessary.
+                console.error(error);
+            },
+        });
+    }
+    addToEngine(collection) {
+        if (!collection || !collection.termCollection) {
+            console.error("Trying to attach collection that has no tilde term id.");
+            return;
+        }
+        // collection.mtStatus = MtCollectionStatus.PROCESSING;
+        // collection.isSynchronized = true;
+        this.mtApi.add(this.engineId, collection)
+            .subscribe({
+            error: () => {
+                // collection.mtStatus = MtCollectionStatus.ERROR;
+                // collection.errorKey = ErrorCode.COLLECTION_IMPORT;
+            }
+        });
+    }
+    create(sourceLanguage, targetLanguage, collectionName, redirectToEdit = true) {
+        return this.termApi.createCollection([sourceLanguage, targetLanguage], collectionName).pipe(tap((collection) => {
+            if (redirectToEdit) {
+                window.open(this.termApi.getEditLink(collection.termCollection.id, sourceLanguage, targetLanguage), "_blank");
+            }
+            this._collections.add(collection);
+            this.emitDataUpdateEvent();
+            this._hasAnyCollections = true;
+        }));
+    }
+    updateIfNecessary(collection) {
+        // collection is not imported and should be attached to engine
+        if (collection.isEdited()) {
+            this.mtApi.add(this.engineId, collection).subscribe((updatedCollection) => {
+                collection.update(updatedCollection);
+            });
+        }
+    }
+    /**
+   *
+   * @returns selected collection id if it is allowed to use collection for translations
+   */
+    selectedIdForTranslation() {
+        if (this.selected?.mtCollection && (this.selected.mtCollection.lastUpdated || this.selected.mtCollection?.status === MtCollectionStatus.READY)) {
+            return this.selected.mtCollection?.id;
+        }
+        return null;
+    }
+    startAutoRefresh(engineId, languages = null, setSelectedFromLocalStorage = false) {
+        this.hardAutoRefresh = true;
+        return this.setEngine(engineId ?? this.engineId, languages ?? this.engineLanguages, setSelectedFromLocalStorage);
+    }
+    stopAutoRefresh() {
+        this.clearTimeout();
+        this.isSoftAutoRefreshOn = false;
+        this.hardAutoRefresh = false;
+    }
+    removeMtCollection(collection, engineId = this.engineId) {
+        return this.mtApi.remove(engineId, collection).pipe(tap((response) => {
+            collection.update(response);
+        }));
+    }
+    scheduleRefresh(timeout) {
+        // if menu is closed and selected collection is not importing anymore - auto refreshing should be cancelled.
+        if (!this.hardAutoRefresh && !this.selected?.isImporting && this.isSoftAutoRefreshOn) {
+            this.stopAutoRefresh();
+            return;
+        }
+        // if hard auto refresho on, auto refresh should be on. If hard autoreferesh is off , refresh needs to be done only if selected is importing.
+        if (this.hardAutoRefresh || (!this.refreshTimeout && (this.isSoftAutoRefreshOn || this.selected?.isImporting))) {
+            const timeoutMs = timeout ?? (this.isAnyImporting ? this.config.termConfig.refreshTimeoutMsWhenImporting : this.config.termConfig.refreshTimeoutMs);
+            this.refreshTimeout = setTimeout(() => {
+                this.refreshTimeout = null;
+                this.refreshCollections();
+            }, timeoutMs);
+        }
+    }
+    /**
+     *
+     * @param newCollections
+     * @param initialRefresh Whether also editable collection fields should be updated. If not initial refresh, editable fields will not be updated.
+     */
+    addCollections(newCollections, initialRefresh) {
+        // sets collection list to this value at the end, so deleted collections are not in the list.
+        for (let collection of newCollections) {
+            // User shouldn't see failed collections if he can't retry to import them.
+            if (!this.hasEditPermissions
+                && collection.mtStatus === MtCollectionStatus.ERROR) {
+                continue;
+            }
+            if (collection.isImporting) {
+                this.isAnyImporting = true;
+            }
+            let existing = CombinedCollection.findExistingCollectionFromList(this.collections, collection);
+            // If term api doesn't have engine languages, collection should not be shown (if it is not already imported somehow);
+            if (!existing && collection.source === EngineTermCollectionSource.TILDE_TERM) {
+                let hasLanguages = true;
+                for (let i = 0; i < this.engineLanguages?.length; i++) {
+                    if (!collection.termCollection.languages?.find(lang => lang.id === this.engineLanguages[i])) {
+                        hasLanguages = false;
+                        break;
+                    }
+                }
+                if (!hasLanguages) {
+                    continue;
+                }
+            }
+            if (!existing) {
+                this._collections.add(collection);
+            }
+            else {
+                existing.update(collection, initialRefresh);
+            }
+        }
+        // this._collections = updatedCollections;
+        this.emitDataUpdateEvent();
+        this._hasAnyCollections = this._collections.size > 0;
+    }
+    /**
+     * Should be called after refresh to check if there is any collections from api that are deleted.
+     */
+    removeDeleted(termResponse, mtResponse, initialRefresh) {
+        for (const collection of this.collections) {
+            const termExistingIx = CombinedCollection.findExistingIndexFromList(termResponse, collection);
+            const mtExistingIx = CombinedCollection.findExistingIndexFromList(mtResponse, collection);
+            if (termExistingIx === null && mtExistingIx === null) {
+                this.collections.delete(collection);
+            }
+            else {
+                if (termExistingIx !== null) {
+                    const existing = termResponse[termExistingIx];
+                    collection.update(existing, initialRefresh);
+                    termResponse.splice(termExistingIx, 1);
+                }
+                else {
+                    collection.deleteTerms();
+                }
+                if (mtExistingIx !== null) {
+                    const existing = mtResponse[mtExistingIx];
+                    collection.update(existing, initialRefresh);
+                    mtResponse.splice(mtExistingIx, 1);
+                }
+                else {
+                    collection.deleteMT();
+                }
+            }
+        }
+    }
+    clearTimeout() {
+        if (this.refreshTimeout) {
+            clearTimeout(this.refreshTimeout);
+            this.refreshTimeout = null;
+        }
+    }
+    setSelectedFromLocalStorage() {
+        // If no collections or selected is already set, it should not be changed from localstorage value. (Usually, localstorage should have the same value).
+        if (this.collections?.size === 0 || this.selected) {
+            return;
+        }
+        const storedId = this.readLocalStorage()?.[this.engineId];
+        if (!storedId) {
+            return;
+        }
+        const existing = Array.from(this.collections).find(item => item.termCollection?.id === storedId || item.mtCollection?.id === storedId);
+        this.selected = existing;
+    }
+    storeSelectedInLocalStorage() {
+        let localStorageObject = this.readLocalStorage();
+        if (!localStorageObject) {
+            localStorageObject = {};
+        }
+        localStorageObject[this.engineId] = this.selected ? (this.selected.termCollection?.id ?? this.selected.mtCollection?.id) : null;
+        // store term id if it exists
+        localStorage.setItem(this.LOCAL_STORAGE_KEY, JSON.stringify(localStorageObject));
+    }
+    readLocalStorage() {
+        const data = localStorage.getItem(this.LOCAL_STORAGE_KEY);
+        try {
+            return JSON.parse(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    emitDataUpdateEvent() {
+        this.onDataUpdate.next(this.collections);
+    }
+}
+TerminologyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TerminologyService, deps: [{ token: i1.TldTranslateConfigService }, { token: i2.TermApiService }, { token: MT_TERM_API_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+TerminologyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TerminologyService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TerminologyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TldTranslateConfigService }, { type: i2.TermApiService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MT_TERM_API_TOKEN]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"terminology.service.js","sourceRoot":"","sources":["../../../../../../../projects/tld-translate/src/lib/modules/tld-term/services/terminology.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { forkJoin, Observable, Subject, tap } from 'rxjs';\r\nimport { MT_TERM_API_TOKEN } from '../../../injection-tokens';\r\nimport { TldTranslateConfigService } from '../../tld-common/services';\r\nimport { EngineTermCollectionSource } from './engine-term/models';\r\nimport { CombinedCollection } from './models/combined-collection.model';\r\nimport { MtCollectionStatus } from './models/mt-collection-status.enum';\r\nimport { IMtTermService } from './models/mt-term-service.model';\r\nimport { TermApiService } from './term-api/term-api.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class TerminologyService {\r\n\r\n  private _selected: CombinedCollection = null;\r\n  get selected() { return this._selected; }\r\n  set selected(val: CombinedCollection) {\r\n    this._selected = val;\r\n    this.storeSelectedInLocalStorage();\r\n    if (!this._selected) {\r\n      return;\r\n    }\r\n\r\n    if (!this._selected.mtCollection) {\r\n      this.addToEngine(this._selected);\r\n    }\r\n\r\n  }\r\n\r\n  private isAnyImporting: boolean;\r\n\r\n\r\n  private _hasAnyCollections: boolean;\r\n  get hasAnyCollections() {\r\n    return this._hasAnyCollections;\r\n  }\r\n\r\n\r\n  get shouldShowPromotion() {\r\n    return !this.hasAnyCollections && !this.hasEditPermissions;\r\n  }\r\n\r\n  get canCreateCollections() {\r\n    return this.config.termConfig.canCreateCollection;\r\n  }\r\n\r\n  get hasEditPermissions() {\r\n    return this.config?.coreConfig.isAuth && this.canCreateCollections && this.config.termConfig.isTermPortalSupported;\r\n  }\r\n\r\n  private _isRefreshingCollections: boolean;\r\n  get isRefreshingCollections() {\r\n    return this._isRefreshingCollections;\r\n  }\r\n\r\n  private _collections: Set<CombinedCollection>;\r\n  get collections() {\r\n    return this._collections;\r\n  }\r\n\r\n  private readonly onDataUpdate = new Subject<Set<CombinedCollection>>();\r\n\r\n  private readonly LOCAL_STORAGE_KEY = \"systemLastCollections\";\r\n  private engineId: string;\r\n  // stores language codes which are used to filter visble collections from term api.\r\n  private engineLanguages: string[];\r\n  private refreshTimeout: any;\r\n  // soft refresh takes in account other params as well.\r\n  private isSoftAutoRefreshOn: boolean;\r\n  // should do autorefresh by ignoring any other params.\r\n  private hardAutoRefresh: boolean;\r\n\r\n  constructor(private readonly config: TldTranslateConfigService,\r\n    private readonly termApi: TermApiService,\r\n    @Inject(MT_TERM_API_TOKEN) private mtApi: IMtTermService) { }\r\n\r\n  setEngine(engineId: string, languages: string[] = null, setSelectedFromLocalStorage = false): Observable<Set<CombinedCollection>> {\r\n    // engine is already set with that ID and no need to refresh it.\r\n    if (engineId !== this.engineId || JSON.stringify(languages) !== JSON.stringify(this.engineLanguages)) {\r\n      this.engineLanguages = languages;\r\n      this.engineId = engineId;\r\n      this._collections = new Set();\r\n      this.emitDataUpdateEvent();\r\n      // avoiding setter, so the null value is not storeed in location since it is not by user action\r\n      this._selected = null;\r\n    }\r\n\r\n    if (this.engineId) {\r\n      this.refreshCollections(setSelectedFromLocalStorage, true);\r\n    }\r\n\r\n    return this.onDataUpdate.asObservable();\r\n  }\r\n\r\n  refreshCollections(setSelectedFromLocalStorage = false, initialRefresh = false) {\r\n    if (!this.engineId || !this.config.termConfig.isCollectionsActivated || this.isRefreshingCollections) {\r\n      return;\r\n    }\r\n\r\n    // clear timeout since this refresh replaces scheduled\r\n    this.clearTimeout();\r\n\r\n    this._isRefreshingCollections = true;\r\n\r\n    let termResponse: CombinedCollection[];\r\n    let mtApiResponse: CombinedCollection[];\r\n\r\n    const observables: Observable<CombinedCollection[]>[] = [\r\n      this.termApi.getCollectionList(this.engineLanguages)\r\n        .pipe(\r\n          tap((response) => termResponse = response)\r\n        ),\r\n      this.mtApi.getList(this.engineId)\r\n        .pipe(\r\n          tap((response) => mtApiResponse = response)\r\n        ),\r\n    ];\r\n    forkJoin(observables).subscribe({\r\n      // do not need response becaue responses are saved in pipe methods\r\n      next: () => {\r\n        this.isAnyImporting = false;\r\n        // note that termResponse and mtapiresponse gets changed during remove method\r\n        this.removeDeleted(termResponse, mtApiResponse, initialRefresh);\r\n        this.addCollections([...mtApiResponse, ...termResponse], initialRefresh);\r\n        if (setSelectedFromLocalStorage) {\r\n          this.setSelectedFromLocalStorage();\r\n        }\r\n        this._isRefreshingCollections = false;\r\n        this.scheduleRefresh();\r\n      },\r\n      error: (error) => {\r\n        this._isRefreshingCollections = false;\r\n        // it is enough to show error only in console. No special thing is necessary.\r\n        console.error(error);\r\n      },\r\n    });\r\n  }\r\n\r\n  addToEngine(collection: CombinedCollection) {\r\n    if (!collection || !collection.termCollection) {\r\n      console.error(\"Trying to attach collection that has no tilde term id.\");\r\n      return;\r\n    }\r\n    // collection.mtStatus = MtCollectionStatus.PROCESSING;\r\n    // collection.isSynchronized = true;\r\n    this.mtApi.add(this.engineId, collection)\r\n      .subscribe({\r\n        error: () => {\r\n          // collection.mtStatus = MtCollectionStatus.ERROR;\r\n          // collection.errorKey = ErrorCode.COLLECTION_IMPORT;\r\n        }\r\n      })\r\n\r\n  }\r\n\r\n  create(sourceLanguage: string, targetLanguage: string, collectionName: string, redirectToEdit = true) {\r\n    return this.termApi.createCollection([sourceLanguage, targetLanguage], collectionName).pipe(\r\n      tap((collection) => {\r\n        if (redirectToEdit) {\r\n          window.open(this.termApi.getEditLink(collection.termCollection.id, sourceLanguage, targetLanguage), \"_blank\");\r\n        }\r\n        this._collections.add(collection);\r\n        this.emitDataUpdateEvent();\r\n        this._hasAnyCollections = true;\r\n      })\r\n    );\r\n  }\r\n\r\n  updateIfNecessary(collection: CombinedCollection) {\r\n    // collection is not imported and should be attached to engine\r\n    if (collection.isEdited()) {\r\n      this.mtApi.add(this.engineId, collection).subscribe((updatedCollection) => {\r\n        collection.update(updatedCollection);\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n *\r\n * @returns selected collection id if it is allowed to use collection for translations\r\n */\r\n  selectedIdForTranslation(): string {\r\n    if (this.selected?.mtCollection && (this.selected.mtCollection.lastUpdated || this.selected.mtCollection?.status === MtCollectionStatus.READY)) {\r\n      return this.selected.mtCollection?.id;\r\n    }\r\n    return null;\r\n  }\r\n\r\n  startAutoRefresh(engineId?: string, languages: string[] = null, setSelectedFromLocalStorage = false) {\r\n    this.hardAutoRefresh = true;\r\n    return this.setEngine(engineId ?? this.engineId, languages ?? this.engineLanguages, setSelectedFromLocalStorage);\r\n  }\r\n\r\n  stopAutoRefresh() {\r\n    this.clearTimeout();\r\n\r\n    this.isSoftAutoRefreshOn = false;\r\n    this.hardAutoRefresh = false;\r\n  }\r\n\r\n  removeMtCollection(collection: CombinedCollection, engineId = this.engineId) {\r\n    return this.mtApi.remove(engineId, collection).pipe(\r\n      tap((response) => {\r\n        collection.update(response);\r\n      })\r\n    );\r\n  }\r\n\r\n  private scheduleRefresh(timeout?: number) {\r\n    // if menu is closed and selected collection is not importing anymore - auto refreshing should be cancelled.\r\n    if (!this.hardAutoRefresh && !this.selected?.isImporting && this.isSoftAutoRefreshOn) {\r\n      this.stopAutoRefresh();\r\n      return;\r\n    }\r\n\r\n    // if hard auto refresho on, auto refresh should be on. If hard autoreferesh is off , refresh needs to be done only if selected is importing.\r\n    if (this.hardAutoRefresh || (!this.refreshTimeout && (this.isSoftAutoRefreshOn || this.selected?.isImporting))) {\r\n      const timeoutMs = timeout ?? (this.isAnyImporting ? this.config.termConfig.refreshTimeoutMsWhenImporting : this.config.termConfig.refreshTimeoutMs);\r\n      this.refreshTimeout = setTimeout(() => {\r\n        this.refreshTimeout = null;\r\n        this.refreshCollections()\r\n      }, timeoutMs);\r\n    }\r\n  }\r\n\r\n  /**\r\n   *\r\n   * @param newCollections\r\n   * @param initialRefresh Whether also editable collection fields should be updated. If not initial refresh, editable fields will not be updated.\r\n   */\r\n  private addCollections(newCollections: Iterable<CombinedCollection>, initialRefresh: boolean) {\r\n    // sets collection list to this value at the end, so deleted collections are not in the list.\r\n    for (let collection of newCollections) {\r\n      // User shouldn't see failed collections if he can't retry to import them.\r\n      if (!this.hasEditPermissions\r\n        && collection.mtStatus === MtCollectionStatus.ERROR) {\r\n        continue;\r\n      }\r\n\r\n      if (collection.isImporting) {\r\n        this.isAnyImporting = true;\r\n      }\r\n      let existing: CombinedCollection = CombinedCollection.findExistingCollectionFromList(this.collections, collection);\r\n\r\n      // If term api doesn't have engine languages, collection should not be shown (if it is not already imported somehow);\r\n      if (!existing && collection.source === EngineTermCollectionSource.TILDE_TERM) {\r\n        let hasLanguages = true;\r\n        for (let i = 0; i < this.engineLanguages?.length; i++) {\r\n          if (!collection.termCollection.languages?.find(lang => lang.id === this.engineLanguages[i])) {\r\n            hasLanguages = false;\r\n            break;\r\n          }\r\n        }\r\n\r\n        if (!hasLanguages) {\r\n          continue;\r\n        }\r\n      }\r\n\r\n      if (!existing) {\r\n        this._collections.add(collection);\r\n      }\r\n      else {\r\n        existing.update(collection, initialRefresh);\r\n      }\r\n    }\r\n\r\n    // this._collections = updatedCollections;\r\n    this.emitDataUpdateEvent();\r\n    this._hasAnyCollections = this._collections.size > 0;\r\n  }\r\n\r\n  /**\r\n   * Should be called after refresh to check if there is any collections from api that are deleted.\r\n   */\r\n  private removeDeleted(termResponse: CombinedCollection[], mtResponse: CombinedCollection[], initialRefresh: boolean) {\r\n\r\n    for (const collection of this.collections) {\r\n      const termExistingIx = CombinedCollection.findExistingIndexFromList(termResponse, collection);\r\n      const mtExistingIx = CombinedCollection.findExistingIndexFromList(mtResponse, collection);\r\n      if (termExistingIx === null && mtExistingIx === null) {\r\n        this.collections.delete(collection);\r\n      }\r\n      else {\r\n        if (termExistingIx !== null) {\r\n          const existing = termResponse[termExistingIx];\r\n          collection.update(existing, initialRefresh);\r\n          termResponse.splice(termExistingIx, 1);\r\n        }\r\n        else {\r\n          collection.deleteTerms();\r\n        }\r\n\r\n        if (mtExistingIx !== null) {\r\n          const existing = mtResponse[mtExistingIx];\r\n          collection.update(existing, initialRefresh);\r\n          mtResponse.splice(mtExistingIx, 1);\r\n        }\r\n        else {\r\n          collection.deleteMT();\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private clearTimeout() {\r\n    if (this.refreshTimeout) {\r\n      clearTimeout(this.refreshTimeout);\r\n      this.refreshTimeout = null;\r\n    }\r\n  }\r\n\r\n  private setSelectedFromLocalStorage() {\r\n    // If no collections or selected is already set, it should not be changed from localstorage value. (Usually, localstorage should have the same value).\r\n    if (this.collections?.size === 0 || this.selected) {\r\n      return\r\n    }\r\n\r\n    const storedId = this.readLocalStorage()?.[this.engineId];\r\n    if (!storedId) {\r\n      return;\r\n    }\r\n\r\n    const existing = Array.from(this.collections).find(item => item.termCollection?.id === storedId || item.mtCollection?.id === storedId);\r\n    this.selected = existing;\r\n  }\r\n\r\n\r\n  private storeSelectedInLocalStorage() {\r\n    let localStorageObject = this.readLocalStorage();\r\n    if (!localStorageObject) {\r\n      localStorageObject = {};\r\n    }\r\n\r\n    localStorageObject[this.engineId] = this.selected ? (this.selected.termCollection?.id ?? this.selected.mtCollection?.id) : null;\r\n    // store term id if it exists\r\n    localStorage.setItem(this.LOCAL_STORAGE_KEY, JSON.stringify(localStorageObject));\r\n  }\r\n\r\n  private readLocalStorage(): any {\r\n    const data = localStorage.getItem(this.LOCAL_STORAGE_KEY);\r\n    try {\r\n      return JSON.parse(data);\r\n    }\r\n    catch {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  private emitDataUpdateEvent() {\r\n    this.onDataUpdate.next(this.collections);\r\n  }\r\n}\r\n"]}

package/esm2020/lib/modules/tld-term/tld-term-collection/tld-term-collection.component.mjs

@@ -1,19 +1,34 @@
 import { Component } from '@angular/core';
 import * as i0 from "@angular/core";
-import * as i1 from "../services/tld-term-collections.service";
-import * as i2 from "@angular/common";
-import * as i3 from "../tld-term-collection-list/tld-term-collection-list.component";
-import * as i4 from "../tld-term-promotion/tld-term-promotion.component";
+import * as i1 from "../services/terminology.service";
+import * as i2 from "../../tld-tooltip/services/tld-system.service";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/flex-layout/flex";
+import * as i5 from "../tld-term-collection-list/tld-term-collection-list.component";
+import * as i6 from "../tld-term-promotion/tld-term-promotion.component";
+import * as i7 from "../create-collection/create-collection.component";
 export class TldTermCollectionComponent {
-    constructor(terms) {
-        this.terms = terms;
+    constructor(terminologyService, systemService) {
+        this.terminologyService = terminologyService;
+        this.systemService = systemService;
+    }
+    get promotion() { return this.terminologyService.shouldShowPromotion; }
+    get hasEditPermissions() { return this.terminologyService.hasEditPermissions; }
+    ngOnInit() {
+        this.subscription = this.systemService.getActiveData().subscribe((data) => {
+            this.sourceLanguageCode = data.sourceLang.lang;
+            this.targetLanguageCode = data.targetLang.lang;
+            this.terminologyService.setEngine(data.systemId, [this.sourceLanguageCode, this.targetLanguageCode]);
+        });
+    }
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
     }
-    get promotion() { return this.terms.shouldShowPromotion; }
 }
-TldTermCollectionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTermCollectionComponent, deps: [{ token: i1.TldTermCollectionsService }], target: i0.ɵɵFactoryTarget.Component });
-TldTermCollectionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: TldTermCollectionComponent, selector: "tld-term-collection", ngImport: i0, template: "<section class=\"tld-collection-list-wrapper\">\r\n  <ng-container *ngIf=\"!promotion\">\r\n    <tld-term-collection-list></tld-term-collection-list>\r\n  </ng-container>\r\n  <ng-container *ngIf=\"promotion\">\r\n    <tld-term-promotion></tld-term-promotion>\r\n  </ng-container>\r\n</section>", styles: [""], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.TldTermCollectionListComponent, selector: "tld-term-collection-list" }, { kind: "component", type: i4.TldTermPromotionComponent, selector: "tld-term-promotion" }] });
+TldTermCollectionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTermCollectionComponent, deps: [{ token: i1.TerminologyService }, { token: i2.TldSystemService }], target: i0.ɵɵFactoryTarget.Component });
+TldTermCollectionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: TldTermCollectionComponent, selector: "tld-term-collection", ngImport: i0, template: "<section class=\"tld-collection-list-wrapper\">\r\n  <ng-container *ngIf=\"!promotion\">\r\n    <tld-term-collection-list></tld-term-collection-list>\r\n    <footer class=\"tld-collection-list-footer\" fxLayout=\"row\" *ngIf=\"hasEditPermissions\">\r\n      <tld-create-collection [sourceLanguageCode]=\"sourceLanguageCode\" [targetLanguageCode]=\"targetLanguageCode\">\r\n      </tld-create-collection>\r\n    </footer>\r\n  </ng-container>\r\n  <ng-container *ngIf=\"promotion\">\r\n    <tld-term-promotion></tld-term-promotion>\r\n  </ng-container>\r\n</section>\r\n", styles: [".tld-collection-list-footer{padding:1em .75em}\n"], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i4.DefaultLayoutDirective, selector: "  [fxLayout], [fxLayout.xs], [fxLayout.sm], [fxLayout.md],  [fxLayout.lg], [fxLayout.xl], [fxLayout.lt-sm], [fxLayout.lt-md],  [fxLayout.lt-lg], [fxLayout.lt-xl], [fxLayout.gt-xs], [fxLayout.gt-sm],  [fxLayout.gt-md], [fxLayout.gt-lg]", inputs: ["fxLayout", "fxLayout.xs", "fxLayout.sm", "fxLayout.md", "fxLayout.lg", "fxLayout.xl", "fxLayout.lt-sm", "fxLayout.lt-md", "fxLayout.lt-lg", "fxLayout.lt-xl", "fxLayout.gt-xs", "fxLayout.gt-sm", "fxLayout.gt-md", "fxLayout.gt-lg"] }, { kind: "component", type: i5.TldTermCollectionListComponent, selector: "tld-term-collection-list" }, { kind: "component", type: i6.TldTermPromotionComponent, selector: "tld-term-promotion" }, { kind: "component", type: i7.CreateCollectionComponent, selector: "tld-create-collection", inputs: ["sourceLanguageCode", "targetLanguageCode"] }] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTermCollectionComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'tld-term-collection', template: "<section class=\"tld-collection-list-wrapper\">\r\n  <ng-container *ngIf=\"!promotion\">\r\n    <tld-term-collection-list></tld-term-collection-list>\r\n  </ng-container>\r\n  <ng-container *ngIf=\"promotion\">\r\n    <tld-term-promotion></tld-term-promotion>\r\n  </ng-container>\r\n</section>" }]
-        }], ctorParameters: function () { return [{ type: i1.TldTermCollectionsService }]; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGxkLXRlcm0tY29sbGVjdGlvbi5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90bGQtdHJhbnNsYXRlL3NyYy9saWIvbW9kdWxlcy90bGQtdGVybS90bGQtdGVybS1jb2xsZWN0aW9uL3RsZC10ZXJtLWNvbGxlY3Rpb24uY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdGxkLXRyYW5zbGF0ZS9zcmMvbGliL21vZHVsZXMvdGxkLXRlcm0vdGxkLXRlcm0tY29sbGVjdGlvbi90bGQtdGVybS1jb2xsZWN0aW9uLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7Ozs7OztBQVExQyxNQUFNLE9BQU8sMEJBQTBCO0lBR3JDLFlBQTZCLEtBQWdDO1FBQWhDLFVBQUssR0FBTCxLQUFLLENBQTJCO0lBQUksQ0FBQztJQUZsRSxJQUFJLFNBQVMsS0FBSyxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsbUJBQW1CLENBQUMsQ0FBQyxDQUFDOzt1SEFEL0MsMEJBQTBCOzJHQUExQiwwQkFBMEIsMkRDUnZDLHdTQU9VOzJGRENHLDBCQUEwQjtrQkFMdEMsU0FBUzsrQkFDRSxxQkFBcUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgVGxkVGVybUNvbGxlY3Rpb25zU2VydmljZSB9IGZyb20gJy4uL3NlcnZpY2VzL3RsZC10ZXJtLWNvbGxlY3Rpb25zLnNlcnZpY2UnO1xyXG5cclxuQENvbXBvbmVudCh7XHJcbiAgc2VsZWN0b3I6ICd0bGQtdGVybS1jb2xsZWN0aW9uJyxcclxuICB0ZW1wbGF0ZVVybDogJy4vdGxkLXRlcm0tY29sbGVjdGlvbi5jb21wb25lbnQuaHRtbCcsXHJcbiAgc3R5bGVVcmxzOiBbJy4vdGxkLXRlcm0tY29sbGVjdGlvbi5jb21wb25lbnQuc2NzcyddXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBUbGRUZXJtQ29sbGVjdGlvbkNvbXBvbmVudCB7XHJcbiAgZ2V0IHByb21vdGlvbigpIHsgcmV0dXJuIHRoaXMudGVybXMuc2hvdWxkU2hvd1Byb21vdGlvbjsgfVxyXG5cclxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IHRlcm1zOiBUbGRUZXJtQ29sbGVjdGlvbnNTZXJ2aWNlKSB7IH1cclxufVxyXG4iLCI8c2VjdGlvbiBjbGFzcz1cInRsZC1jb2xsZWN0aW9uLWxpc3Qtd3JhcHBlclwiPlxyXG4gIDxuZy1jb250YWluZXIgKm5nSWY9XCIhcHJvbW90aW9uXCI+XHJcbiAgICA8dGxkLXRlcm0tY29sbGVjdGlvbi1saXN0PjwvdGxkLXRlcm0tY29sbGVjdGlvbi1saXN0PlxyXG4gIDwvbmctY29udGFpbmVyPlxyXG4gIDxuZy1jb250YWluZXIgKm5nSWY9XCJwcm9tb3Rpb25cIj5cclxuICAgIDx0bGQtdGVybS1wcm9tb3Rpb24+PC90bGQtdGVybS1wcm9tb3Rpb24+XHJcbiAgPC9uZy1jb250YWluZXI+XHJcbjwvc2VjdGlvbj4iXX0=
+            args: [{ selector: 'tld-term-collection', template: "<section class=\"tld-collection-list-wrapper\">\r\n  <ng-container *ngIf=\"!promotion\">\r\n    <tld-term-collection-list></tld-term-collection-list>\r\n    <footer class=\"tld-collection-list-footer\" fxLayout=\"row\" *ngIf=\"hasEditPermissions\">\r\n      <tld-create-collection [sourceLanguageCode]=\"sourceLanguageCode\" [targetLanguageCode]=\"targetLanguageCode\">\r\n      </tld-create-collection>\r\n    </footer>\r\n  </ng-container>\r\n  <ng-container *ngIf=\"promotion\">\r\n    <tld-term-promotion></tld-term-promotion>\r\n  </ng-container>\r\n</section>\r\n", styles: [".tld-collection-list-footer{padding:1em .75em}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.TerminologyService }, { type: i2.TldSystemService }]; } });
+//# sourceMappingURL=data:application/json;base64,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