@tilde-nlp/ngx-translate 2.0.2 → 2.1.0

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

@@ -0,0 +1,51 @@
+import { Component, Input } from '@angular/core';
+import { ErrorCode } from '../../tld-common/models';
+import { TldTermCreateCollectionDialogComponent } from '../tld-term-create-collection-dialog/tld-term-create-collection-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "../services/terminology.service";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/flex-layout/extended";
+export class CreateCollectionComponent {
+    constructor(translate, dialog, terminologyService) {
+        this.translate = translate;
+        this.dialog = dialog;
+        this.terminologyService = terminologyService;
+    }
+    ngOnInit() {
+    }
+    create() {
+        const localizationKey = "TERM_COLLECTIONS.DEFAULT_COLLECTION_NAME";
+        this.translate.get(localizationKey).subscribe((collectionName) => {
+            const dialogRef = this.dialog.open(TldTermCreateCollectionDialogComponent, {
+                minWidth: '300px',
+                maxWidth: '700px',
+                data: { collectionName: collectionName }
+            });
+            dialogRef.afterClosed().subscribe(collectionName => {
+                if (!collectionName) {
+                    return;
+                }
+                this.terminologyService.create(this.sourceLanguageCode, this.targetLanguageCode, collectionName).subscribe({
+                    error: (err) => {
+                        console.error(err);
+                        const error = { ErrorCode: ErrorCode.COLLECTION_CREATE };
+                        throw error;
+                    }
+                });
+            });
+        });
+    }
+}
+CreateCollectionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CreateCollectionComponent, deps: [{ token: i1.TranslateService }, { token: i2.MatDialog }, { token: i3.TerminologyService }], target: i0.ɵɵFactoryTarget.Component });
+CreateCollectionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: CreateCollectionComponent, selector: "tld-create-collection", inputs: { sourceLanguageCode: "sourceLanguageCode", targetLanguageCode: "targetLanguageCode" }, ngImport: i0, template: "<button mat-flat-button color=\"accent\" (click)=\"create()\" fxHide.lt-sm>\r\n  {{'TERM_COLLECTIONS.CREATE' | translate}}\r\n</button>\r\n", styles: [""], dependencies: [{ kind: "component", type: i4.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { 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: "pipe", type: i1.TranslatePipe, name: "translate" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CreateCollectionComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tld-create-collection', template: "<button mat-flat-button color=\"accent\" (click)=\"create()\" fxHide.lt-sm>\r\n  {{'TERM_COLLECTIONS.CREATE' | translate}}\r\n</button>\r\n" }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.MatDialog }, { type: i3.TerminologyService }]; }, propDecorators: { sourceLanguageCode: [{
+                type: Input
+            }], targetLanguageCode: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/tld-term/index.mjs

@@ -4,4 +4,5 @@ export * from './tld-term-menu/tld-term-menu.component';
 export * from './tld-term-promotion/tld-term-promotion.component';
 export * from './tld-term-collection-list/tld-term-collection-list.component';
 export * from './tld-term-create-collection-dialog/tld-term-create-collection-dialog.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90bGQtdHJhbnNsYXRlL3NyYy9saWIvbW9kdWxlcy90bGQtdGVybS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMscURBQXFELENBQUM7QUFDcEUsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLG1EQUFtRCxDQUFDO0FBQ2xFLGNBQWMsK0RBQStELENBQUM7QUFDOUUsY0FBYyxpRkFBaUYsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdGxkLXRlcm0ubW9kdWxlJztcclxuZXhwb3J0ICogZnJvbSAnLi90bGQtdGVybS1jb2xsZWN0aW9uL3RsZC10ZXJtLWNvbGxlY3Rpb24uY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi90bGQtdGVybS1tZW51L3RsZC10ZXJtLW1lbnUuY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi90bGQtdGVybS1wcm9tb3Rpb24vdGxkLXRlcm0tcHJvbW90aW9uLmNvbXBvbmVudCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vdGxkLXRlcm0tY29sbGVjdGlvbi1saXN0L3RsZC10ZXJtLWNvbGxlY3Rpb24tbGlzdC5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL3RsZC10ZXJtLWNyZWF0ZS1jb2xsZWN0aW9uLWRpYWxvZy90bGQtdGVybS1jcmVhdGUtY29sbGVjdGlvbi1kaWFsb2cuY29tcG9uZW50JztcclxuIl19
+export * from './create-collection/create-collection.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90bGQtdHJhbnNsYXRlL3NyYy9saWIvbW9kdWxlcy90bGQtdGVybS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMscURBQXFELENBQUM7QUFDcEUsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLG1EQUFtRCxDQUFDO0FBQ2xFLGNBQWMsK0RBQStELENBQUM7QUFDOUUsY0FBYyxpRkFBaUYsQ0FBQztBQUNoRyxjQUFjLGlEQUFpRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90bGQtdGVybS5tb2R1bGUnO1xyXG5leHBvcnQgKiBmcm9tICcuL3RsZC10ZXJtLWNvbGxlY3Rpb24vdGxkLXRlcm0tY29sbGVjdGlvbi5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL3RsZC10ZXJtLW1lbnUvdGxkLXRlcm0tbWVudS5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL3RsZC10ZXJtLXByb21vdGlvbi90bGQtdGVybS1wcm9tb3Rpb24uY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi90bGQtdGVybS1jb2xsZWN0aW9uLWxpc3QvdGxkLXRlcm0tY29sbGVjdGlvbi1saXN0LmNvbXBvbmVudCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vdGxkLXRlcm0tY3JlYXRlLWNvbGxlY3Rpb24tZGlhbG9nL3RsZC10ZXJtLWNyZWF0ZS1jb2xsZWN0aW9uLWRpYWxvZy5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NyZWF0ZS1jb2xsZWN0aW9uL2NyZWF0ZS1jb2xsZWN0aW9uLmNvbXBvbmVudCc7XHJcbiJdfQ==

package/esm2020/lib/modules/tld-term/services/api-v1/models/mt-term-collection-v1-status.enum.mjs

@@ -0,0 +1,7 @@
+export var MtTermCollectionV1Status;
+(function (MtTermCollectionV1Status) {
+    MtTermCollectionV1Status["READY"] = "Ready";
+    MtTermCollectionV1Status["PROCESSING"] = "Processing";
+    MtTermCollectionV1Status["ERROR"] = "Error";
+})(MtTermCollectionV1Status || (MtTermCollectionV1Status = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXQtdGVybS1jb2xsZWN0aW9uLXYxLXN0YXR1cy5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdGxkLXRyYW5zbGF0ZS9zcmMvbGliL21vZHVsZXMvdGxkLXRlcm0vc2VydmljZXMvYXBpLXYxL21vZGVscy9tdC10ZXJtLWNvbGxlY3Rpb24tdjEtc3RhdHVzLmVudW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksd0JBSVg7QUFKRCxXQUFZLHdCQUF3QjtJQUNsQywyQ0FBZSxDQUFBO0lBQ2YscURBQXlCLENBQUE7SUFDekIsMkNBQWUsQ0FBQTtBQUNqQixDQUFDLEVBSlcsd0JBQXdCLEtBQXhCLHdCQUF3QixRQUluQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIE10VGVybUNvbGxlY3Rpb25WMVN0YXR1cyB7XHJcbiAgUkVBRFkgPSBcIlJlYWR5XCIsXHJcbiAgUFJPQ0VTU0lORyA9IFwiUHJvY2Vzc2luZ1wiLFxyXG4gIEVSUk9SID0gXCJFcnJvclwiXHJcbn1cclxuIl19

package/esm2020/lib/modules/tld-term/services/api-v1/models/mt-term-collection-v1.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXQtdGVybS1jb2xsZWN0aW9uLXYxLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdGxkLXRyYW5zbGF0ZS9zcmMvbGliL21vZHVsZXMvdGxkLXRlcm0vc2VydmljZXMvYXBpLXYxL21vZGVscy9tdC10ZXJtLWNvbGxlY3Rpb24tdjEubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE10VGVybUNvbGxlY3Rpb25WMVN0YXR1cyB9IGZyb20gXCIuL210LXRlcm0tY29sbGVjdGlvbi12MS1zdGF0dXMuZW51bVwiO1xyXG5cclxuZXhwb3J0IGludGVyZmFjZSBNdFRlcm1Db2xsZWN0aW9uVjEge1xyXG4gIENvcnB1c0lkOiBzdHJpbmc7XHJcbiAgTWVzc2FnZTogc3RyaW5nO1xyXG4gIFN0YXR1czogTXRUZXJtQ29sbGVjdGlvblYxU3RhdHVzO1xyXG4gIFRpbGRlVGVybUlkPzogc3RyaW5nO1xyXG4gIFRpdGxlOiBzdHJpbmc7XHJcbiAgVHlwZTogc3RyaW5nO1xyXG4gIEF0dGFjaG1lbnREYXRlVGltZTogc3RyaW5nO1xyXG4gIENvdW50OiBudW1iZXI7XHJcbiAgUHJlcGFyZWREYXRlVGltZTogc3RyaW5nO1xyXG59XHJcbiJdfQ==

package/esm2020/lib/modules/tld-term/services/api-v1/mt-term-v1.service.mjs

@@ -0,0 +1,53 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import { Common } from '../../../tld-common/models';
+import { CombinedCollection } from '../models/combined-collection.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../../tld-common/services";
+export class MtTermV1Service {
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+    }
+    add(engineId, collection) {
+        const url = `${this.config.coreConfig.translationServiceUrl}AttachTermsFromTildeTerm`;
+        return this.http.get(url, { params: { systemID: engineId, tildeTermColectionID: collection.termId } })
+            .pipe(map(data => this.convertToCombinedCollection(data)));
+    }
+    getList(engineId) {
+        const headers = Common.getAuthHeaders(this.config);
+        const url = `${this.config.coreConfig.translationServiceUrl}GetDetailedSystemTermCorpora`;
+        const params = { systemID: engineId };
+        return this.http.get(url, { headers, params }).pipe(map((data) => {
+            const mtCollections = [];
+            data.forEach((collection) => {
+                mtCollections.push(this.convertToCombinedCollection(collection));
+            });
+            return mtCollections;
+        }));
+    }
+    remove(engineId, collection) {
+        throw new Error("not Implemented");
+    }
+    convertToCombinedCollection(collection) {
+        const convertedMtCollection = {
+            id: collection.CorpusId,
+            termId: collection.TildeTermId,
+            lastUpdated: new Date(collection.AttachmentDateTime),
+            name: collection.Title,
+            // any because enums should overlap
+            status: collection.Status
+        };
+        return new CombinedCollection(null, convertedMtCollection);
+    }
+}
+MtTermV1Service.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MtTermV1Service, deps: [{ token: i1.HttpClient }, { token: i2.TldTranslateConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+MtTermV1Service.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MtTermV1Service, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MtTermV1Service, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.TldTranslateConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/tld-term/services/api-v2/mt-term-v2.service.mjs

@@ -0,0 +1,67 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import { CombinedCollection } from '../models/combined-collection.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../tld-common/services";
+import * as i2 from "../engine-term/eninge-term-api.service";
+export class MtTermV2Service {
+    constructor(config, engineTermApi) {
+        this.config = config;
+        this.engineTermApi = engineTermApi;
+        this.baseUrl = this.config.termConfig.engineTermUrl;
+    }
+    add(engineId, collection) {
+        if (!collection.mtCollection) {
+            const params = {
+                collectionId: collection.termId,
+                default: collection.editables.default,
+                collectionSource: collection.source,
+                scope: collection.editables.scope
+            };
+            return this.engineTermApi.add(engineId, params)
+                .pipe(map(collection => this.convertToCombinedCollection(collection)));
+        }
+        else {
+            const params = {
+                default: collection.editables.default,
+                scope: collection.editables.scope
+            };
+            return this.engineTermApi.update(engineId, collection.termId, params)
+                .pipe(map(collection => this.convertToCombinedCollection(collection)));
+        }
+    }
+    getList(engineId) {
+        return this.engineTermApi.getList(engineId)
+            .pipe(map((collections) => {
+            const converted = [];
+            collections?.termCollections?.forEach((collection) => {
+                converted.push(this.convertToCombinedCollection(collection));
+            });
+            return converted;
+        }));
+    }
+    remove(engineId, collection) {
+        return this.engineTermApi.remove(engineId, collection.mtCollection.id).pipe(map(collection => this.convertToCombinedCollection(collection)));
+    }
+    convertToCombinedCollection(collection) {
+        const convertedMtCollection = {
+            id: collection.id,
+            lastUpdated: new Date(collection.collectionUpdatedAt),
+            name: collection.name,
+            status: collection.status,
+            termId: collection.collectionId,
+            default: collection.default,
+            scope: collection.scope
+        };
+        return new CombinedCollection(null, convertedMtCollection);
+    }
+}
+MtTermV2Service.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MtTermV2Service, deps: [{ token: i1.TldTranslateConfigService }, { token: i2.EningeTermApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+MtTermV2Service.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MtTermV2Service, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MtTermV2Service, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TldTranslateConfigService }, { type: i2.EningeTermApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/tld-term/services/engine-term/eninge-term-api.service.mjs

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../../tld-common/services";
+export class EningeTermApiService {
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+        this.baseUrl = this.config.termConfig.engineTermUrl;
+    }
+    add(engineId, params) {
+        return this.http.post(`${this.baseUrl}/${engineId}/terms`, params);
+    }
+    update(engineId, collectionId, params) {
+        return this.http.put(`${this.baseUrl}/${engineId}/terms/${collectionId}`, params);
+    }
+    getList(engineId) {
+        return this.http.get(`${this.baseUrl}/${engineId}/terms`, { params: { engineId } });
+    }
+    remove(engineId, collectionId) {
+        return this.http.delete(`${this.baseUrl}/${engineId}/terms/${collectionId}`);
+    }
+}
+EningeTermApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EningeTermApiService, deps: [{ token: i1.HttpClient }, { token: i2.TldTranslateConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+EningeTermApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EningeTermApiService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: EningeTermApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.TldTranslateConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/tld-term/services/engine-term/models/add-engine-terms-request-params.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRkLWVuZ2luZS10ZXJtcy1yZXF1ZXN0LXBhcmFtcy5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3RsZC10cmFuc2xhdGUvc3JjL2xpYi9tb2R1bGVzL3RsZC10ZXJtL3NlcnZpY2VzL2VuZ2luZS10ZXJtL21vZGVscy9hZGQtZW5naW5lLXRlcm1zLXJlcXVlc3QtcGFyYW1zLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFbmdpbmVUZXJtQ29sbGVjdGlvblNjb3BlIH0gZnJvbSBcIi4vZW5naW5lLXRlcm0tY29sbGVjdGlvbi1zY29wZS5lbnVtXCI7XHJcbmltcG9ydCB7IEVuZ2luZVRlcm1Db2xsZWN0aW9uU291cmNlIH0gZnJvbSBcIi4vZW5naW5lLXRlcm0tY29sbGVjdGlvbi1zb3VyY2UuZW51bVwiO1xyXG5cclxuZXhwb3J0IGludGVyZmFjZSBBZGRFbmdpbmVUZXJtc1JlcXVlc3RQYXJhbXMge1xyXG4gIGNvbGxlY3Rpb25JZDogc3RyaW5nO1xyXG4gIHNjb3BlOiBFbmdpbmVUZXJtQ29sbGVjdGlvblNjb3BlO1xyXG4gIGRlZmF1bHQ6IGJvb2xlYW47XHJcbiAgY29sbGVjdGlvblNvdXJjZTogRW5naW5lVGVybUNvbGxlY3Rpb25Tb3VyY2U7XHJcbn1cclxuIl19

package/esm2020/lib/modules/tld-term/services/engine-term/models/engine-term-collection-list.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5naW5lLXRlcm0tY29sbGVjdGlvbi1saXN0Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdGxkLXRyYW5zbGF0ZS9zcmMvbGliL21vZHVsZXMvdGxkLXRlcm0vc2VydmljZXMvZW5naW5lLXRlcm0vbW9kZWxzL2VuZ2luZS10ZXJtLWNvbGxlY3Rpb24tbGlzdC5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRW5naW5lVGVybUNvbGxlY3Rpb24gfSBmcm9tIFwiLi9lbmdpbmUtdGVybS1jb2xsZWN0aW9uLm1vZGVsXCI7XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEVuZ2luZVRlcm1Db2xsZWN0aW9uTGlzdCB7XHJcbiAgdGVybUNvbGxlY3Rpb25zOiBFbmdpbmVUZXJtQ29sbGVjdGlvbltdO1xyXG59XHJcbiJdfQ==

package/esm2020/lib/modules/tld-term/services/engine-term/models/engine-term-collection-scope.enum.mjs

@@ -0,0 +1,6 @@
+export var EngineTermCollectionScope;
+(function (EngineTermCollectionScope) {
+    EngineTermCollectionScope["GLOBAL"] = "Global";
+    EngineTermCollectionScope["GROUP"] = "Group";
+})(EngineTermCollectionScope || (EngineTermCollectionScope = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5naW5lLXRlcm0tY29sbGVjdGlvbi1zY29wZS5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdGxkLXRyYW5zbGF0ZS9zcmMvbGliL21vZHVsZXMvdGxkLXRlcm0vc2VydmljZXMvZW5naW5lLXRlcm0vbW9kZWxzL2VuZ2luZS10ZXJtLWNvbGxlY3Rpb24tc2NvcGUuZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSx5QkFHWDtBQUhELFdBQVkseUJBQXlCO0lBQ25DLDhDQUFpQixDQUFBO0lBQ2pCLDRDQUFlLENBQUE7QUFDakIsQ0FBQyxFQUhXLHlCQUF5QixLQUF6Qix5QkFBeUIsUUFHcEMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBFbmdpbmVUZXJtQ29sbGVjdGlvblNjb3Ble1xyXG4gIEdMT0JBTCA9IFwiR2xvYmFsXCIsXHJcbiAgR1JPVVAgPSBcIkdyb3VwXCJcclxufVxyXG4iXX0=

package/esm2020/lib/modules/tld-term/services/engine-term/models/engine-term-collection-source.enum.mjs

@@ -0,0 +1,6 @@
+export var EngineTermCollectionSource;
+(function (EngineTermCollectionSource) {
+    EngineTermCollectionSource["TILDE_TERM"] = "TildeTerm";
+    EngineTermCollectionSource["FILE"] = "File";
+})(EngineTermCollectionSource || (EngineTermCollectionSource = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5naW5lLXRlcm0tY29sbGVjdGlvbi1zb3VyY2UuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3RsZC10cmFuc2xhdGUvc3JjL2xpYi9tb2R1bGVzL3RsZC10ZXJtL3NlcnZpY2VzL2VuZ2luZS10ZXJtL21vZGVscy9lbmdpbmUtdGVybS1jb2xsZWN0aW9uLXNvdXJjZS5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLDBCQUdYO0FBSEQsV0FBWSwwQkFBMEI7SUFDcEMsc0RBQXdCLENBQUE7SUFDeEIsMkNBQWEsQ0FBQTtBQUNmLENBQUMsRUFIVywwQkFBMEIsS0FBMUIsMEJBQTBCLFFBR3JDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gRW5naW5lVGVybUNvbGxlY3Rpb25Tb3VyY2Uge1xyXG4gIFRJTERFX1RFUk0gPSBcIlRpbGRlVGVybVwiLFxyXG4gIEZJTEUgPSBcIkZpbGVcIlxyXG59XHJcbiJdfQ==

package/esm2020/lib/modules/tld-term/services/engine-term/models/engine-term-collection-status.enum.mjs

@@ -0,0 +1,11 @@
+export var EngineTermCollectionStatus;
+(function (EngineTermCollectionStatus) {
+    EngineTermCollectionStatus["QUEUING"] = "Queuing";
+    EngineTermCollectionStatus["FETCHING"] = "Fetching";
+    EngineTermCollectionStatus["PREPROCESSING"] = "Preprocessing";
+    EngineTermCollectionStatus["DELETING"] = "Deleting";
+    EngineTermCollectionStatus["READY"] = "Ready";
+    EngineTermCollectionStatus["ERROR"] = "Error";
+    EngineTermCollectionStatus["DELETED"] = "Deleted";
+})(EngineTermCollectionStatus || (EngineTermCollectionStatus = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5naW5lLXRlcm0tY29sbGVjdGlvbi1zdGF0dXMuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3RsZC10cmFuc2xhdGUvc3JjL2xpYi9tb2R1bGVzL3RsZC10ZXJtL3NlcnZpY2VzL2VuZ2luZS10ZXJtL21vZGVscy9lbmdpbmUtdGVybS1jb2xsZWN0aW9uLXN0YXR1cy5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLDBCQVFYO0FBUkQsV0FBWSwwQkFBMEI7SUFDcEMsaURBQW1CLENBQUE7SUFDbkIsbURBQXFCLENBQUE7SUFDckIsNkRBQStCLENBQUE7SUFDL0IsbURBQXFCLENBQUE7SUFDckIsNkNBQWUsQ0FBQTtJQUNmLDZDQUFlLENBQUE7SUFDZixpREFBbUIsQ0FBQTtBQUNyQixDQUFDLEVBUlcsMEJBQTBCLEtBQTFCLDBCQUEwQixRQVFyQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIEVuZ2luZVRlcm1Db2xsZWN0aW9uU3RhdHVzIHtcclxuICBRVUVVSU5HID0gXCJRdWV1aW5nXCIsXHJcbiAgRkVUQ0hJTkcgPSBcIkZldGNoaW5nXCIsXHJcbiAgUFJFUFJPQ0VTU0lORyA9IFwiUHJlcHJvY2Vzc2luZ1wiLFxyXG4gIERFTEVUSU5HID0gXCJEZWxldGluZ1wiLFxyXG4gIFJFQURZID0gXCJSZWFkeVwiLFxyXG4gIEVSUk9SID0gXCJFcnJvclwiLFxyXG4gIERFTEVURUQgPSBcIkRlbGV0ZWRcIlxyXG59XHJcbiJdfQ==

package/esm2020/lib/modules/tld-term/services/engine-term/models/engine-term-collection.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5naW5lLXRlcm0tY29sbGVjdGlvbi5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3RsZC10cmFuc2xhdGUvc3JjL2xpYi9tb2R1bGVzL3RsZC10ZXJtL3NlcnZpY2VzL2VuZ2luZS10ZXJtL21vZGVscy9lbmdpbmUtdGVybS1jb2xsZWN0aW9uLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFbmdpbmVUZXJtQ29sbGVjdGlvblNjb3BlIH0gZnJvbSBcIi4vZW5naW5lLXRlcm0tY29sbGVjdGlvbi1zY29wZS5lbnVtXCI7XHJcbmltcG9ydCB7IEVuZ2luZVRlcm1Db2xsZWN0aW9uU291cmNlIH0gZnJvbSBcIi4vZW5naW5lLXRlcm0tY29sbGVjdGlvbi1zb3VyY2UuZW51bVwiO1xyXG5pbXBvcnQgeyBFbmdpbmVUZXJtQ29sbGVjdGlvblN0YXR1cyB9IGZyb20gXCIuL2VuZ2luZS10ZXJtLWNvbGxlY3Rpb24tc3RhdHVzLmVudW1cIjtcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgRW5naW5lVGVybUNvbGxlY3Rpb24ge1xyXG4gIGlkOiBzdHJpbmc7XHJcbiAgY29sbGVjdGlvbklkOiBzdHJpbmc7XHJcbiAgc2NvcGU6IEVuZ2luZVRlcm1Db2xsZWN0aW9uU2NvcGU7XHJcbiAgZGVmYXVsdDogYm9vbGVhbjtcclxuICBuYW1lOiBzdHJpbmc7XHJcbiAgc3RhdHVzOiBFbmdpbmVUZXJtQ29sbGVjdGlvblN0YXR1cztcclxuICBwcm9ncmVzczogbnVtYmVyO1xyXG4gIGNvbGxlY3Rpb25Tb3VyY2U6IEVuZ2luZVRlcm1Db2xsZWN0aW9uU291cmNlO1xyXG4gIGNvbGxlY3Rpb25VcGRhdGVkQXQ6IHN0cmluZztcclxufVxyXG4iXX0=

package/esm2020/lib/modules/tld-term/services/engine-term/models/index.mjs

@@ -0,0 +1,8 @@
+export * from './add-engine-terms-request-params.model';
+export * from './update-engine-terms-request-params.model';
+export * from './engine-term-collection-scope.enum';
+export * from './engine-term-collection-source.enum';
+export * from './engine-term-collection-status.enum';
+export * from './engine-term-collection.model';
+export * from './engine-term-collection-list.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90bGQtdHJhbnNsYXRlL3NyYy9saWIvbW9kdWxlcy90bGQtdGVybS9zZXJ2aWNlcy9lbmdpbmUtdGVybS9tb2RlbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLDRDQUE0QyxDQUFDO0FBQzNELGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyxzQ0FBc0MsQ0FBQztBQUNyRCxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxxQ0FBcUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYWRkLWVuZ2luZS10ZXJtcy1yZXF1ZXN0LXBhcmFtcy5tb2RlbCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vdXBkYXRlLWVuZ2luZS10ZXJtcy1yZXF1ZXN0LXBhcmFtcy5tb2RlbCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZW5naW5lLXRlcm0tY29sbGVjdGlvbi1zY29wZS5lbnVtJztcclxuZXhwb3J0ICogZnJvbSAnLi9lbmdpbmUtdGVybS1jb2xsZWN0aW9uLXNvdXJjZS5lbnVtJztcclxuZXhwb3J0ICogZnJvbSAnLi9lbmdpbmUtdGVybS1jb2xsZWN0aW9uLXN0YXR1cy5lbnVtJztcclxuZXhwb3J0ICogZnJvbSAnLi9lbmdpbmUtdGVybS1jb2xsZWN0aW9uLm1vZGVsJztcclxuZXhwb3J0ICogZnJvbSAnLi9lbmdpbmUtdGVybS1jb2xsZWN0aW9uLWxpc3QubW9kZWwnO1xyXG4iXX0=

package/esm2020/lib/modules/tld-term/services/engine-term/models/update-engine-terms-request-params.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLWVuZ2luZS10ZXJtcy1yZXF1ZXN0LXBhcmFtcy5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3RsZC10cmFuc2xhdGUvc3JjL2xpYi9tb2R1bGVzL3RsZC10ZXJtL3NlcnZpY2VzL2VuZ2luZS10ZXJtL21vZGVscy91cGRhdGUtZW5naW5lLXRlcm1zLXJlcXVlc3QtcGFyYW1zLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFbmdpbmVUZXJtQ29sbGVjdGlvblNjb3BlIH0gZnJvbSBcIi4vZW5naW5lLXRlcm0tY29sbGVjdGlvbi1zY29wZS5lbnVtXCI7XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIFVwZGF0ZUVuZ2luZVRlcm1zUmVxdWVzdFBhcmFtcyB7XHJcbiAgc2NvcGU6IEVuZ2luZVRlcm1Db2xsZWN0aW9uU2NvcGU7XHJcbiAgZGVmYXVsdDogYm9vbGVhbjtcclxufVxyXG4iXX0=

package/esm2020/lib/modules/tld-term/services/index.mjs

@@ -1,4 +1,4 @@
-export * from './tld-term-collections.service';
-export * from './term-api.service';
-export * from './mt-collections-api.service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90bGQtdHJhbnNsYXRlL3NyYy9saWIvbW9kdWxlcy90bGQtdGVybS9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyw4QkFBOEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdGxkLXRlcm0tY29sbGVjdGlvbnMuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vdGVybS1hcGkuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbXQtY29sbGVjdGlvbnMtYXBpLnNlcnZpY2UnO1xyXG4iXX0=
+export * from "./terminology.service";
+export * from "./engine-term/eninge-term-api.service";
+export * from "./term-api";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90bGQtdHJhbnNsYXRlL3NyYy9saWIvbW9kdWxlcy90bGQtdGVybS9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyxZQUFZLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi90ZXJtaW5vbG9neS5zZXJ2aWNlXCI7XHJcbmV4cG9ydCAqIGZyb20gXCIuL2VuZ2luZS10ZXJtL2VuaW5nZS10ZXJtLWFwaS5zZXJ2aWNlXCI7XHJcbmV4cG9ydCAqIGZyb20gXCIuL3Rlcm0tYXBpXCI7XHJcbiJdfQ==

package/esm2020/lib/modules/tld-term/services/models/combined-collection-tooltip-key.enum.mjs

@@ -0,0 +1,6 @@
+export var CombinedCollectionTooltipKey;
+(function (CombinedCollectionTooltipKey) {
+    CombinedCollectionTooltipKey["NO_ENTRIES"] = "NO_ENTRIES";
+    CombinedCollectionTooltipKey["IMPORTING"] = "IMPORTING";
+})(CombinedCollectionTooltipKey || (CombinedCollectionTooltipKey = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tYmluZWQtY29sbGVjdGlvbi10b29sdGlwLWtleS5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdGxkLXRyYW5zbGF0ZS9zcmMvbGliL21vZHVsZXMvdGxkLXRlcm0vc2VydmljZXMvbW9kZWxzL2NvbWJpbmVkLWNvbGxlY3Rpb24tdG9vbHRpcC1rZXkuZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSw0QkFHWDtBQUhELFdBQVksNEJBQTRCO0lBQ3RDLHlEQUF5QixDQUFBO0lBQ3pCLHVEQUF1QixDQUFBO0FBQ3pCLENBQUMsRUFIVyw0QkFBNEIsS0FBNUIsNEJBQTRCLFFBR3ZDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gQ29tYmluZWRDb2xsZWN0aW9uVG9vbHRpcEtleXtcclxuICBOT19FTlRSSUVTID0gXCJOT19FTlRSSUVTXCIsXHJcbiAgSU1QT1JUSU5HID0gXCJJTVBPUlRJTkdcIixcclxufVxyXG4iXX0=

package/esm2020/lib/modules/tld-term/services/models/combined-collection.model.mjs

@@ -0,0 +1,190 @@
+import { EngineTermCollectionScope, EngineTermCollectionSource } from "../engine-term/models";
+import { CombinedCollectionTooltipKey } from "./combined-collection-tooltip-key.enum";
+import { MtCollectionStatus } from "./mt-collection-status.enum";
+/**
+ * Class that joins collection from term api and its imported collection from MT api.
+ */
+export class CombinedCollection {
+    //#endregion
+    constructor(termApiCollection, mtCollection) {
+        //#endregion
+        //#region Editable MT (api v2) fields
+        this.editables = {};
+        //#endregion
+        //#region Getters for common fields
+        // It is possible to optimize getters, by setting some of the values in update method, but it is left this way, so that data is more consistent.
+        // Otherwise it might be easy to miss some property updating and get wrong data in future.
+        this._isSynchronized = true;
+        this.mtCollection = mtCollection;
+        this.termCollection = termApiCollection;
+        this.update(null);
+    }
+    static findExistingCollectionFromList(collections, collection) {
+        for (const col of collections) {
+            if ((col.termId && col.termId == collection.termId) ||
+                (col.mtCollection?.id && col.mtCollection.id == collection.mtCollection?.id)) {
+                return col;
+            }
+        }
+        return null;
+    }
+    static findExistingIndexFromList(collections, collection) {
+        let i = 0;
+        for (const col of collections) {
+            if ((col.termId && col.termId == collection.termId) ||
+                (col.mtCollection?.id && col.mtCollection.id == collection.mtCollection?.id)) {
+                return i;
+            }
+            i += 1;
+        }
+        return null;
+    }
+    /**
+     * Weather collection is synchronized with term portal collection. If no term collection, value is set to true.
+     */
+    get isSynchronized() {
+        return this._isSynchronized;
+    }
+    /**
+     * Determines if collections is 'syncable'. Returns true if it is not synced or if synchronization has failed and status is error.
+     */
+    get syncButtonVissible() {
+        return !this.isSynchronized || (this.termCollection?.modifyDate && this.mtStatus === MtCollectionStatus.ERROR);
+    }
+    /**
+     * If not ready or error, then collection is importing.
+     */
+    get isImporting() {
+        return this.mtCollection && CombinedCollection.importingStatuses.includes(this.mtCollection?.status);
+    }
+    ;
+    /**
+     * Term collection id. Returns value from term collection or from mt, if term collection not existing.
+     */
+    get termId() {
+        return this.termCollection?.id ?? this.mtCollection?.termId;
+    }
+    get mtStatus() {
+        return this.mtCollection?.status;
+    }
+    /**
+     * Last updated date from mt api.
+     */
+    get lastUpdated() {
+        return this.mtCollection?.lastUpdated;
+    }
+    /**
+     * Collection name. If has term collection, takes from there. If not, then returns mt collection name.
+     */
+    get name() {
+        return this.termCollection?.name ?? this.mtCollection?.name;
+    }
+    /**
+     * Entry count from term api.
+     */
+    get termEntries() {
+        return this.termCollection?.entryCount;
+    }
+    get default() {
+        return this.mtCollection?.default;
+    }
+    /**
+     * Status from mt api or custom "NOT_IN_USE" status if not imported in mt.s
+     */
+    get status() {
+        return this.mtStatus ?? MtCollectionStatus.NOT_IN_USE;
+    }
+    /**
+     * Scope can be edited only if has mt collcetion or term collection is being prepared for import.
+     */
+    get canEditScope() {
+        return this.mtCollection || this.editables.default;
+    }
+    /**
+     * Updates collection with values from new collection.
+     * @param collection collection from which should be updated.
+     * @param initialRefresh if set to true, editable fields will also be updated.
+     */
+    update(collection, initialRefresh = true) {
+        if (collection?.termCollection) {
+            this.termCollection = collection.termCollection;
+        }
+        if (collection?.mtCollection) {
+            this.mtCollection = collection.mtCollection;
+        }
+        if (initialRefresh) {
+            this.updateEditables();
+        }
+        this.updateIsSynchronized();
+        this.updateTooltipKey();
+        this.updateSource();
+    }
+    /**
+     * If some of editables are edited.
+     *
+     * if collection not imported and enabled not set, method will return true, because you cannot update collection if it is not imported or is not meant to be imported.
+     *
+     * @returns true if collection is edited, false if not.
+     */
+    isEdited() {
+        // if collection not imported and enabled not set, should not update collection.
+        if (!this.mtCollection && !this.editables.default) {
+            return false;
+        }
+        else if ((this.mtCollection?.default !== this.editables.default)
+            || (this.mtCollection && this.editables.scope !== this.mtCollection.scope)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Deletes term collection and its properties.
+     */
+    deleteTerms() {
+        this.termCollection = null;
+        this.update(null);
+    }
+    /**
+     * Deletes mt collection and its properties.
+     */
+    deleteMT() {
+        this.mtCollection = null;
+        this.update(null);
+    }
+    //#region Private methods
+    updateIsSynchronized() {
+        let isSynchronized = true;
+        const termModified = this.termCollection?.modifyDate;
+        const lastMtUpdated = this.mtCollection?.lastUpdated;
+        if (termModified && lastMtUpdated) {
+            isSynchronized = termModified < lastMtUpdated;
+        }
+        this._isSynchronized = isSynchronized;
+    }
+    updateSource() {
+        if (this.termCollection) {
+            this.source = EngineTermCollectionSource.TILDE_TERM;
+        }
+        else if (this.mtCollection) {
+            this.source = EngineTermCollectionSource.FILE;
+        }
+    }
+    updateTooltipKey() {
+        if (this.termCollection?.entryCount === 0) {
+            this.termTooltipKey = CombinedCollectionTooltipKey.NO_ENTRIES;
+        }
+        else if (this.isImporting) {
+            this.termTooltipKey = CombinedCollectionTooltipKey.IMPORTING;
+        }
+        else {
+            this.termTooltipKey = null;
+        }
+    }
+    updateEditables() {
+        this.editables.default = this.mtCollection?.default;
+        this.editables.scope = this.mtCollection?.scope ?? EngineTermCollectionScope.GLOBAL;
+    }
+}
+//#region Static properties
+CombinedCollection.importingStatuses = [MtCollectionStatus.FETCHING, MtCollectionStatus.PREPROCESSING, MtCollectionStatus.PROCESSING, MtCollectionStatus.QUEUING];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"combined-collection.model.js","sourceRoot":"","sources":["../../../../../../../../projects/tld-translate/src/lib/modules/tld-term/services/models/combined-collection.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { EngineTermCollectionScope, EngineTermCollectionSource } from \"../engine-term/models\";\r\nimport { ITldTermCollection } from \"../term-api/models/tld-term-collection.model\";\r\nimport { CombinedCollectionTooltipKey } from \"./combined-collection-tooltip-key.enum\";\r\nimport { MtCollectionStatus } from \"./mt-collection-status.enum\";\r\nimport { MtCollection } from \"./mt-collection.model\";\r\n\r\n/**\r\n * Class that joins collection from term api and its imported collection from MT api.\r\n */\r\nexport class CombinedCollection {\r\n  mtCollection: MtCollection;\r\n  termCollection: ITldTermCollection;\r\n  termTooltipKey: CombinedCollectionTooltipKey;\r\n  source: EngineTermCollectionSource;\r\n\r\n  //#region Static properties\r\n  static importingStatuses = [MtCollectionStatus.FETCHING, MtCollectionStatus.PREPROCESSING, MtCollectionStatus.PROCESSING, MtCollectionStatus.QUEUING];\r\n\r\n  static findExistingCollectionFromList(collections: Iterable<CombinedCollection>, collection: CombinedCollection) {\r\n    for (const col of collections) {\r\n      if ((col.termId && col.termId == collection.termId) ||\r\n        (col.mtCollection?.id && col.mtCollection.id == collection.mtCollection?.id)) {\r\n        return col;\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  static findExistingIndexFromList(collections: Iterable<CombinedCollection>, collection: CombinedCollection): number {\r\n    let i = 0;\r\n    for (const col of collections) {\r\n      if ((col.termId && col.termId == collection.termId) ||\r\n        (col.mtCollection?.id && col.mtCollection.id == collection.mtCollection?.id)) {\r\n        return i;\r\n      }\r\n      i += 1;\r\n    }\r\n    return null;\r\n  }\r\n  //#endregion\r\n\r\n  //#region Editable MT (api v2) fields\r\n  editables: {\r\n    default?: boolean;\r\n    scope?: EngineTermCollectionScope;\r\n  } = {};\r\n  //#endregion\r\n\r\n  //#region Getters for common fields\r\n  // It is possible to optimize getters, by setting some of the values in update method, but it is left this way, so that data is more consistent.\r\n  // Otherwise it might be easy to miss some property updating and get wrong data in future.\r\n\r\n  private _isSynchronized: boolean = true;\r\n  /**\r\n   * Weather collection is synchronized with term portal collection. If no term collection, value is set to true.\r\n   */\r\n  get isSynchronized() {\r\n    return this._isSynchronized;\r\n  }\r\n\r\n  /**\r\n   * Determines if collections is 'syncable'. Returns true if it is not synced or if synchronization has failed and status is error.\r\n   */\r\n  get syncButtonVissible() {\r\n    return !this.isSynchronized || (this.termCollection?.modifyDate && this.mtStatus === MtCollectionStatus.ERROR);\r\n  }\r\n\r\n  /**\r\n   * If not ready or error, then collection is importing.\r\n   */\r\n  get isImporting(): boolean {\r\n    return this.mtCollection && CombinedCollection.importingStatuses.includes(this.mtCollection?.status);\r\n  };\r\n\r\n  /**\r\n   * Term collection id. Returns value from term collection or from mt, if term collection not existing.\r\n   */\r\n  get termId() {\r\n    return this.termCollection?.id ?? this.mtCollection?.termId;\r\n  }\r\n\r\n  get mtStatus() {\r\n    return this.mtCollection?.status;\r\n  }\r\n\r\n  /**\r\n   * Last updated date from mt api.\r\n   */\r\n  get lastUpdated() {\r\n    return this.mtCollection?.lastUpdated;\r\n  }\r\n\r\n  /**\r\n   * Collection name. If has term collection, takes from there. If not, then returns mt collection name.\r\n   */\r\n  get name() {\r\n    return this.termCollection?.name ?? this.mtCollection?.name;\r\n  }\r\n\r\n  /**\r\n   * Entry count from term api.\r\n   */\r\n  get termEntries() {\r\n    return this.termCollection?.entryCount;\r\n  }\r\n\r\n  get default() {\r\n    return this.mtCollection?.default;\r\n  }\r\n\r\n  /**\r\n   * Status from mt api or custom \"NOT_IN_USE\" status if not imported in mt.s\r\n   */\r\n  get status() {\r\n    return this.mtStatus ?? MtCollectionStatus.NOT_IN_USE;\r\n  }\r\n\r\n  /**\r\n   * Scope can be edited only if has mt collcetion or term collection is being prepared for import.\r\n   */\r\n  get canEditScope() {\r\n    return this.mtCollection || this.editables.default;\r\n  }\r\n\r\n  //#endregion\r\n\r\n  constructor(termApiCollection: ITldTermCollection, mtCollection: MtCollection) {\r\n    this.mtCollection = mtCollection;\r\n    this.termCollection = termApiCollection;\r\n    this.update(null);\r\n  }\r\n\r\n  /**\r\n   * Updates collection with values from new collection.\r\n   * @param collection collection from which should be updated.\r\n   * @param initialRefresh if set to true, editable fields will also be updated.\r\n   */\r\n  update(collection: CombinedCollection, initialRefresh = true) {\r\n    if (collection?.termCollection) {\r\n      this.termCollection = collection.termCollection;\r\n    }\r\n\r\n    if (collection?.mtCollection) {\r\n      this.mtCollection = collection.mtCollection;\r\n    }\r\n\r\n    if (initialRefresh) {\r\n      this.updateEditables();\r\n    }\r\n\r\n    this.updateIsSynchronized();\r\n    this.updateTooltipKey();\r\n    this.updateSource();\r\n  }\r\n\r\n  /**\r\n   * If some of editables are edited.\r\n   *\r\n   * if collection not imported and enabled not set, method will return true, because you cannot update collection if it is not imported or is not meant to be imported.\r\n   *\r\n   * @returns true if collection is edited, false if not.\r\n   */\r\n  isEdited() {\r\n    // if collection not imported and enabled not set, should not update collection.\r\n    if (!this.mtCollection && !this.editables.default) {\r\n      return false;\r\n    }\r\n    else if ((this.mtCollection?.default !== this.editables.default)\r\n      || (this.mtCollection && this.editables.scope !== this.mtCollection.scope)) {\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /**\r\n   * Deletes term collection and its properties.\r\n   */\r\n  deleteTerms() {\r\n    this.termCollection = null;\r\n    this.update(null);\r\n  }\r\n\r\n\r\n  /**\r\n   * Deletes mt collection and its properties.\r\n   */\r\n  deleteMT() {\r\n    this.mtCollection = null;\r\n    this.update(null);\r\n  }\r\n\r\n  //#region Private methods\r\n  private updateIsSynchronized() {\r\n    let isSynchronized = true;\r\n    const termModified = this.termCollection?.modifyDate;\r\n    const lastMtUpdated = this.mtCollection?.lastUpdated;\r\n    if (termModified && lastMtUpdated) {\r\n      isSynchronized = termModified < lastMtUpdated;\r\n    }\r\n    this._isSynchronized = isSynchronized;\r\n  }\r\n\r\n  private updateSource() {\r\n    if (this.termCollection) {\r\n      this.source = EngineTermCollectionSource.TILDE_TERM;\r\n    }\r\n    else if (this.mtCollection) {\r\n      this.source = EngineTermCollectionSource.FILE;\r\n    }\r\n  }\r\n\r\n  private updateTooltipKey() {\r\n    if (this.termCollection?.entryCount === 0) {\r\n      this.termTooltipKey = CombinedCollectionTooltipKey.NO_ENTRIES;\r\n    }\r\n    else if (this.isImporting) {\r\n      this.termTooltipKey = CombinedCollectionTooltipKey.IMPORTING;\r\n    }\r\n    else {\r\n      this.termTooltipKey = null;\r\n    }\r\n  }\r\n\r\n  private updateEditables() {\r\n    this.editables.default = this.mtCollection?.default;\r\n    this.editables.scope = this.mtCollection?.scope ?? EngineTermCollectionScope.GLOBAL;\r\n  }\r\n  //#endregion\r\n}\r\n"]}

package/esm2020/lib/modules/tld-term/services/models/index.mjs

@@ -0,0 +1,6 @@
+export * from './combined-collection-tooltip-key.enum';
+export * from './combined-collection.model';
+export * from './mt-collection-status.enum';
+export * from './mt-collection.model';
+export * from './mt-term-service.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90bGQtdHJhbnNsYXRlL3NyYy9saWIvbW9kdWxlcy90bGQtdGVybS9zZXJ2aWNlcy9tb2RlbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3Q0FBd0MsQ0FBQztBQUN2RCxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb21iaW5lZC1jb2xsZWN0aW9uLXRvb2x0aXAta2V5LmVudW0nO1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbWJpbmVkLWNvbGxlY3Rpb24ubW9kZWwnO1xyXG5leHBvcnQgKiBmcm9tICcuL210LWNvbGxlY3Rpb24tc3RhdHVzLmVudW0nO1xyXG5leHBvcnQgKiBmcm9tICcuL210LWNvbGxlY3Rpb24ubW9kZWwnO1xyXG5leHBvcnQgKiBmcm9tICcuL210LXRlcm0tc2VydmljZS5tb2RlbCc7XHJcbiJdfQ==

package/esm2020/lib/modules/tld-term/services/models/mt-collection-status.enum.mjs

@@ -0,0 +1,14 @@
+export var MtCollectionStatus;
+(function (MtCollectionStatus) {
+    MtCollectionStatus["QUEUING"] = "Queuing";
+    MtCollectionStatus["FETCHING"] = "Fetching";
+    MtCollectionStatus["PREPROCESSING"] = "Preprocessing";
+    MtCollectionStatus["DELETING"] = "Deleting";
+    MtCollectionStatus["READY"] = "Ready";
+    MtCollectionStatus["DELETED"] = "Deleted";
+    MtCollectionStatus["PROCESSING"] = "Processing";
+    MtCollectionStatus["ERROR"] = "Error";
+    // basic status created in frontend
+    MtCollectionStatus["NOT_IN_USE"] = "NotInUse";
+})(MtCollectionStatus || (MtCollectionStatus = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXQtY29sbGVjdGlvbi1zdGF0dXMuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3RsZC10cmFuc2xhdGUvc3JjL2xpYi9tb2R1bGVzL3RsZC10ZXJtL3NlcnZpY2VzL21vZGVscy9tdC1jb2xsZWN0aW9uLXN0YXR1cy5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE1BQU0sQ0FBTixJQUFZLGtCQVdYO0FBWEQsV0FBWSxrQkFBa0I7SUFDNUIseUNBQW1CLENBQUE7SUFDbkIsMkNBQXFCLENBQUE7SUFDckIscURBQStCLENBQUE7SUFDL0IsMkNBQXFCLENBQUE7SUFDckIscUNBQWUsQ0FBQTtJQUNmLHlDQUFtQixDQUFBO0lBQ25CLCtDQUF5QixDQUFBO0lBQ3pCLHFDQUFlLENBQUE7SUFDZixtQ0FBbUM7SUFDbkMsNkNBQXVCLENBQUE7QUFDekIsQ0FBQyxFQVhXLGtCQUFrQixLQUFsQixrQkFBa0IsUUFXN0IiLCJzb3VyY2VzQ29udGVudCI6WyJcclxuZXhwb3J0IGVudW0gTXRDb2xsZWN0aW9uU3RhdHVzIHtcclxuICBRVUVVSU5HID0gXCJRdWV1aW5nXCIsXHJcbiAgRkVUQ0hJTkcgPSBcIkZldGNoaW5nXCIsXHJcbiAgUFJFUFJPQ0VTU0lORyA9IFwiUHJlcHJvY2Vzc2luZ1wiLFxyXG4gIERFTEVUSU5HID0gXCJEZWxldGluZ1wiLFxyXG4gIFJFQURZID0gXCJSZWFkeVwiLFxyXG4gIERFTEVURUQgPSBcIkRlbGV0ZWRcIixcclxuICBQUk9DRVNTSU5HID0gXCJQcm9jZXNzaW5nXCIsXHJcbiAgRVJST1IgPSBcIkVycm9yXCIsXHJcbiAgLy8gYmFzaWMgc3RhdHVzIGNyZWF0ZWQgaW4gZnJvbnRlbmRcclxuICBOT1RfSU5fVVNFID0gXCJOb3RJblVzZVwiXHJcbn1cclxuIl19