@tilde-nlp/ngx-translate 1.0.0

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

@@ -0,0 +1,253 @@
+import { Injectable } from '@angular/core';
+import { forkJoin } from 'rxjs';
+import { map, tap } from 'rxjs/operators';
+import { ErrorCode } from '../../tld-common/models/errors/error-codes.enum';
+import { ConvertedCollectionType } from '../models/converted-collection-type.model';
+import { MtCollectionStatus } from '../models/mt-collection-status.model';
+import { TldConvertedCollection } from '../models/tld-converted-collection.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../tld-common/services";
+import * as i2 from "../../tld-tooltip/services";
+import * as i3 from "./term-api.service";
+import * as i4 from "./mt-collections-api.service";
+export class TldTermCollectionsService {
+    constructor(config, tldSystem, termApi, mtApi) {
+        this.config = config;
+        this.tldSystem = tldSystem;
+        this.termApi = termApi;
+        this.mtApi = mtApi;
+        this._selected = null;
+        this.LOCAL_STORAGE_KEY = "systemLastCollections";
+        this.tldSystem.getActiveData()
+            .subscribe((active) => {
+            this.sourceLanguageCode = active?.sourceLang.lang;
+            this.targetLanguageCode = active?.targetLang.lang;
+            this.activeSystemId = active?.systemId || null;
+            this._collections = new Set();
+            // avoiding setter, so the null value is not storeed in location since it is not by user action
+            this._selected = null;
+            if (active && this.tldSystem.isTerminologySupported(active?.system)) {
+                this.refreshCollections(true);
+            }
+        });
+    }
+    get selected() { return this._selected; }
+    set selected(val) {
+        this._selected = val;
+        this.storeSelectedInLocalStorage();
+        if (!this._selected) {
+            return;
+        }
+        if (!this._selected.id) {
+            this.addCollectionToSystem(this._selected);
+        }
+    }
+    get collections() {
+        return this._collections;
+    }
+    get isRefreshingCollections() {
+        return this._isRefreshingCollections;
+    }
+    get canCreateCollections() {
+        return this.config.termConfig.canCreateCollection;
+    }
+    get hasEditPermissions() {
+        return this.config?.coreConfig.isAuth && this.canCreateCollections && this.config.termConfig.isTermPortalSupported;
+    }
+    get hasAnyCollections() {
+        return this._hasAnyCollections;
+    }
+    get shouldShowPromotion() {
+        return !this.hasAnyCollections && !this.hasEditPermissions;
+    }
+    onMenuOpen() {
+        this.menuOpened = true;
+        if (!this.shouldShowPromotion) {
+            this.startAutoRefresh();
+        }
+    }
+    onMenuClose() {
+        this.menuOpened = false;
+        // if menu is closed, but selected collection still syncing, auto refresh should be kept opened.
+        if (this.selected?.mtStatus !== MtCollectionStatus.PROCESSING) {
+            this.stopAutoRefresh();
+        }
+    }
+    addCollectionToSystem(collection) {
+        if (!collection || !collection.termId) {
+            console.error("Trying to attach collection that has no tilde term id.");
+            return;
+        }
+        collection.mtStatus = MtCollectionStatus.PROCESSING;
+        collection.isSynchronized = true;
+        this.mtApi.attachTermsFromTildeTerm(this.activeSystemId, collection.termId)
+            .subscribe(() => { }, () => {
+            collection.mtStatus = MtCollectionStatus.ERROR;
+            collection.errorKey = ErrorCode.COLLECTION_IMPORT;
+        });
+    }
+    create(defaultLanguages, collectionName) {
+        return this.termApi.createCollection(defaultLanguages, collectionName).pipe(map(collection => new TldConvertedCollection(collection, this.sourceLanguageCode, this.targetLanguageCode)), tap((collection) => {
+            this._collections.add(collection);
+            this._hasAnyCollections = true;
+        }));
+    }
+    refreshCollections(setSelectedFromLocalStorage = false) {
+        if (!this.activeSystemId
+            || !this.config.termConfig.isCollectionsActivated) {
+            return;
+        }
+        this._isRefreshingCollections = true;
+        const observables = [
+            this.termApi.getCollectionList(this.sourceLanguageCode, this.targetLanguageCode),
+            this.mtApi.loadMTCollections(this.activeSystemId, this.sourceLanguageCode, this.targetLanguageCode)
+        ];
+        forkJoin(observables).subscribe((response) => {
+            this.isAnyImporting = false;
+            // TO DO. Doesn't seem to be clean approach with syncing collections. Maybe some cleaner solution possible?
+            this.removeDeletedFromTerms(response[0]);
+            this.updateCollections([...response[0], ...response[1]]);
+            if (setSelectedFromLocalStorage) {
+                this.setSelectedFromLocalStorage();
+            }
+            this._isRefreshingCollections = false;
+            this.scheduleRefresh();
+        }, (error) => {
+            this._isRefreshingCollections = false;
+            // it is enough to show error only in console. No special thing is necessary.
+            console.error(error);
+        });
+    }
+    /**
+     *
+     * @returns selected collection id if it is allowed to use collection for translations
+     */
+    selectedIdForTranslation() {
+        if (this.selected && (this.selected.mtPreparedDateTime || this.selected.mtStatus === MtCollectionStatus.READY)) {
+            return this.selected.id;
+        }
+        return null;
+    }
+    startAutoRefresh() {
+        this.isAutoRefreshingOn = true;
+        this.scheduleRefresh(0);
+    }
+    stopAutoRefresh() {
+        if (this.refreshTimeout) {
+            clearTimeout(this.refreshTimeout);
+            this.refreshTimeout = null;
+        }
+        this.isAutoRefreshingOn = false;
+    }
+    scheduleRefresh(timeout) {
+        // if menu is closed and selected collection is not importing anymore - auto refreshing should be cancelled.
+        if (!this.menuOpened && !this.selected?.isImporting && this.isAutoRefreshingOn) {
+            this.stopAutoRefresh();
+            return;
+        }
+        // if menu is opened, auto refresh should be on. If menu is closed, refresh needs to be done only if selected is importing.
+        if (!this.refreshTimeout && (this.isAutoRefreshingOn || 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);
+        }
+    }
+    /**
+     * Should be called after refresh to check if there is any collections from term api that are deleted.
+     */
+    removeDeletedFromTerms(refreshedList) {
+        for (const collection of this.collections) {
+            if (!collection.termId) {
+                continue;
+            }
+            const exists = refreshedList.find(refreshedCollection => refreshedCollection.importedFrom === ConvertedCollectionType.Term && refreshedCollection.termId === collection.termId);
+            if (!exists) {
+                // Removes collection if it hasn't been imported.
+                if (!collection.id) {
+                    this.collections.delete(collection);
+                }
+                else {
+                    collection.deletedFromTermApi();
+                }
+            }
+        }
+    }
+    updateCollections(refreshedCollections) {
+        // sets collection list to this value at the end, so deleted collections are not in the list.
+        const updatedCollections = new Set();
+        for (let collection of refreshedCollections) {
+            // User shouldn't see failed collections if he can't retry to import them.
+            if (!this.hasEditPermissions
+                && collection.importedFrom === ConvertedCollectionType.MT
+                && collection.mtStatus === MtCollectionStatus.ERROR) {
+                continue;
+            }
+            if (collection.isImporting) {
+                this.isAnyImporting = true;
+            }
+            let existing = TldConvertedCollection.findExistingCollectionFromList(this.collections, collection);
+            // Term Id should be set only for entities coming from term API, because collection can be deleted, but key would still be in MT api.
+            // But term id is necessary to do the previous check to sync collections - it can be set to null only after update.
+            if (collection.importedFrom === ConvertedCollectionType.MT) {
+                // Collections from MT should be only visible when Ready or collection is being processed, but it has already been created before and it can be used.
+                if (!(collection.mtStatus === MtCollectionStatus.READY
+                    || (collection.mtStatus === MtCollectionStatus.PROCESSING && collection.mtPreparedDateTime)
+                    || existing)) {
+                    continue;
+                }
+                collection.termId = null;
+            }
+            if (existing) {
+                existing.update(collection);
+            }
+            else {
+                this.collections.add(collection);
+            }
+            const editedCollection = existing ?? collection;
+            updatedCollections.add(editedCollection);
+        }
+        this._collections = updatedCollections;
+        this._hasAnyCollections = updatedCollections.size > 0;
+    }
+    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.activeSystemId];
+        if (!storedId) {
+            return;
+        }
+        const existing = Array.from(this.collections).find(item => item.id === storedId || item.termId === storedId);
+        this.selected = existing;
+    }
+    storeSelectedInLocalStorage() {
+        let localStorageObject = this.readLocalStorage();
+        if (!localStorageObject) {
+            localStorageObject = {};
+        }
+        localStorageObject[this.activeSystemId] = this.selected ? (this.selected.termId ?? this.selected.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;
+        }
+    }
+}
+TldTermCollectionsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTermCollectionsService, deps: [{ token: i1.TldTranslateConfigService }, { token: i2.TldSystemService }, { token: i3.TermApiService }, { token: i4.MtCollectionsApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+TldTermCollectionsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTermCollectionsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTermCollectionsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TldTranslateConfigService }, { type: i2.TldSystemService }, { type: i3.TermApiService }, { type: i4.MtCollectionsApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tld-term-collections.service.js","sourceRoot":"","sources":["../../../../../../../projects/tld-translate/src/lib/modules/tld-term/services/tld-term-collections.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { forkJoin, Observable } from 'rxjs';\r\nimport { map, tap } from 'rxjs/operators';\r\nimport { ErrorCode } from '../../tld-common/models/errors/error-codes.enum';\r\nimport { TldTranslateConfigService } from '../../tld-common/services';\r\nimport { TldSystemService } from '../../tld-tooltip/services';\r\nimport { ConvertedCollectionType } from '../models/converted-collection-type.model';\r\nimport { MtCollectionStatus } from '../models/mt-collection-status.model';\r\nimport { TldConvertedCollection } from '../models/tld-converted-collection.model';\r\nimport { MtCollectionsApiService } from './mt-collections-api.service';\r\nimport { TermApiService } from './term-api.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class TldTermCollectionsService {\r\n\r\n  private _selected: TldConvertedCollection = null;\r\n  get selected() { return this._selected; }\r\n  set selected(val: TldConvertedCollection) {\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.id) {\r\n      this.addCollectionToSystem(this._selected);\r\n    }\r\n\r\n  }\r\n\r\n  // set instead of array because only distinct values should be in list and with set no manual checks are necessary.\r\n  private _collections: Set<TldConvertedCollection>;\r\n  get collections() {\r\n    return this._collections;\r\n  }\r\n\r\n  private _isRefreshingCollections: boolean;\r\n  get isRefreshingCollections() {\r\n    return this._isRefreshingCollections;\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 _hasAnyCollections: boolean;\r\n  get hasAnyCollections() {\r\n    return this._hasAnyCollections;\r\n  }\r\n\r\n  get shouldShowPromotion() {\r\n    return !this.hasAnyCollections && !this.hasEditPermissions;\r\n  }\r\n\r\n  private isAutoRefreshingOn: boolean;\r\n  private sourceLanguageCode: string;\r\n  private targetLanguageCode: string;\r\n  private activeSystemId: string;\r\n  private refreshTimeout: any;\r\n  private isAnyImporting: boolean;\r\n  private menuOpened: boolean;\r\n\r\n  private readonly LOCAL_STORAGE_KEY = \"systemLastCollections\";\r\n\r\n  constructor(private readonly config: TldTranslateConfigService,\r\n    private readonly tldSystem: TldSystemService,\r\n    private readonly termApi: TermApiService,\r\n    private readonly mtApi: MtCollectionsApiService) {\r\n    this.tldSystem.getActiveData()\r\n      .subscribe((active) => {\r\n        this.sourceLanguageCode = active?.sourceLang.lang;\r\n        this.targetLanguageCode = active?.targetLang.lang;\r\n        this.activeSystemId = active?.systemId || null;\r\n        this._collections = new Set();\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        if (active && this.tldSystem.isTerminologySupported(active?.system)) {\r\n          this.refreshCollections(true);\r\n        }\r\n      });\r\n  }\r\n\r\n  onMenuOpen() {\r\n    this.menuOpened = true;\r\n    if (!this.shouldShowPromotion) {\r\n      this.startAutoRefresh();\r\n    }\r\n  }\r\n\r\n  onMenuClose() {\r\n    this.menuOpened = false;\r\n    // if menu is closed, but selected collection still syncing, auto refresh should be kept opened.\r\n    if (this.selected?.mtStatus !== MtCollectionStatus.PROCESSING) {\r\n      this.stopAutoRefresh();\r\n    }\r\n  }\r\n\r\n  addCollectionToSystem(collection: TldConvertedCollection) {\r\n    if (!collection || !collection.termId) {\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.attachTermsFromTildeTerm(this.activeSystemId, collection.termId)\r\n      .subscribe(() => { },\r\n        () => {\r\n          collection.mtStatus = MtCollectionStatus.ERROR;\r\n          collection.errorKey = ErrorCode.COLLECTION_IMPORT;\r\n        });\r\n  }\r\n\r\n  create(defaultLanguages: string[], collectionName: string) {\r\n    return this.termApi.createCollection(defaultLanguages, collectionName).pipe(\r\n      map(collection => new TldConvertedCollection(collection, this.sourceLanguageCode, this.targetLanguageCode)),\r\n      tap((collection) => {\r\n        this._collections.add(collection);\r\n        this._hasAnyCollections = true;\r\n      })\r\n    );\r\n  }\r\n\r\n  refreshCollections(setSelectedFromLocalStorage = false) {\r\n    if (!this.activeSystemId\r\n      || !this.config.termConfig.isCollectionsActivated) {\r\n      return;\r\n    }\r\n    this._isRefreshingCollections = true;\r\n    const observables: Observable<TldConvertedCollection[]>[] = [\r\n      this.termApi.getCollectionList(this.sourceLanguageCode, this.targetLanguageCode),\r\n      this.mtApi.loadMTCollections(this.activeSystemId, this.sourceLanguageCode, this.targetLanguageCode)\r\n    ];\r\n\r\n    forkJoin(observables).subscribe(\r\n      (response) => {\r\n        this.isAnyImporting = false;\r\n        // TO DO. Doesn't seem to be clean approach with syncing collections. Maybe some cleaner solution possible?\r\n        this.removeDeletedFromTerms(response[0]);\r\n        this.updateCollections([...response[0], ...response[1]]);\r\n        if (setSelectedFromLocalStorage) {\r\n          this.setSelectedFromLocalStorage();\r\n        }\r\n        this._isRefreshingCollections = false;\r\n        this.scheduleRefresh();\r\n      }, (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   *\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 && (this.selected.mtPreparedDateTime || this.selected.mtStatus === MtCollectionStatus.READY)) {\r\n      return this.selected.id;\r\n    }\r\n    return null;\r\n  }\r\n\r\n  private startAutoRefresh() {\r\n    this.isAutoRefreshingOn = true;\r\n    this.scheduleRefresh(0);\r\n  }\r\n\r\n  private stopAutoRefresh() {\r\n    if (this.refreshTimeout) {\r\n      clearTimeout(this.refreshTimeout);\r\n      this.refreshTimeout = null;\r\n    }\r\n\r\n    this.isAutoRefreshingOn = false;\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.menuOpened && !this.selected?.isImporting && this.isAutoRefreshingOn) {\r\n      this.stopAutoRefresh();\r\n      return;\r\n    }\r\n\r\n    // if menu is opened, auto refresh should be on. If menu is closed, refresh needs to be done only if selected is importing.\r\n    if (!this.refreshTimeout && (this.isAutoRefreshingOn || 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   * Should be called after refresh to check if there is any collections from term api that are deleted.\r\n   */\r\n  private removeDeletedFromTerms(refreshedList: TldConvertedCollection[]) {\r\n    for (const collection of this.collections) {\r\n      if (!collection.termId) {\r\n        continue;\r\n      }\r\n      const exists = refreshedList.find(refreshedCollection => refreshedCollection.importedFrom === ConvertedCollectionType.Term && refreshedCollection.termId === collection.termId);\r\n      if (!exists) {\r\n        // Removes collection if it hasn't been imported.\r\n        if (!collection.id) {\r\n          this.collections.delete(collection);\r\n        }\r\n        else {\r\n          collection.deletedFromTermApi();\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private updateCollections(refreshedCollections: TldConvertedCollection[]) {\r\n    // sets collection list to this value at the end, so deleted collections are not in the list.\r\n    const updatedCollections = new Set<TldConvertedCollection>();\r\n    for (let collection of refreshedCollections) {\r\n      // User shouldn't see failed collections if he can't retry to import them.\r\n      if (!this.hasEditPermissions\r\n        && collection.importedFrom === ConvertedCollectionType.MT\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\r\n      let existing: TldConvertedCollection = TldConvertedCollection.findExistingCollectionFromList(this.collections, collection);\r\n\r\n      // Term Id should be set only for entities coming from term API, because collection can be deleted, but key would still be in MT api.\r\n      // But term id is necessary to do the previous check to sync collections - it can be set to null only after update.\r\n      if (collection.importedFrom === ConvertedCollectionType.MT) {\r\n        // Collections from MT should be only visible when Ready or collection is being processed, but it has already been created before and it can be used.\r\n        if (!(collection.mtStatus === MtCollectionStatus.READY\r\n          || (collection.mtStatus === MtCollectionStatus.PROCESSING && collection.mtPreparedDateTime)\r\n          || existing)) {\r\n          continue;\r\n        }\r\n        collection.termId = null;\r\n      }\r\n\r\n      if (existing) {\r\n        existing.update(collection);\r\n      }\r\n      else {\r\n        this.collections.add(collection);\r\n      }\r\n\r\n      const editedCollection = existing ?? collection;\r\n      updatedCollections.add(editedCollection);\r\n    }\r\n    this._collections = updatedCollections;\r\n    this._hasAnyCollections = updatedCollections.size > 0;\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.activeSystemId];\r\n    if (!storedId) {\r\n      return;\r\n    }\r\n\r\n    const existing = Array.from(this.collections).find(item => item.id === storedId || item.termId === 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.activeSystemId] = this.selected ? (this.selected.termId ?? this.selected.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"]}

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

@@ -0,0 +1,19 @@
+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";
+export class TldTermCollectionComponent {
+    constructor(terms) {
+        this.terms = terms;
+    }
+    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" }] });
+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=

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

@@ -0,0 +1,99 @@
+import { Component } from '@angular/core';
+import { ErrorCode } from '../../tld-common/models/errors/error-codes.enum';
+import { MtCollectionStatus } from '../models/mt-collection-status.model';
+import { TldTermCreateCollectionDialogComponent } from '../tld-term-create-collection-dialog/tld-term-create-collection-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/tld-term-collections.service";
+import * as i2 from "../../tld-common/services";
+import * as i3 from "../../tld-tooltip/services";
+import * as i4 from "@angular/material/dialog";
+import * as i5 from "@ngx-translate/core";
+import * as i6 from "@angular/forms";
+import * as i7 from "@angular/common";
+import * as i8 from "@angular/material/button";
+import * as i9 from "@angular/material/tooltip";
+import * as i10 from "@angular/material/radio";
+import * as i11 from "@angular/flex-layout/flex";
+import * as i12 from "@angular/flex-layout/extended";
+import * as i13 from "@angular/material/progress-spinner";
+export class TldTermCollectionListComponent {
+    constructor(collectionService, config, tldSystem, dialog, translate, alerts) {
+        this.collectionService = collectionService;
+        this.config = config;
+        this.tldSystem = tldSystem;
+        this.dialog = dialog;
+        this.translate = translate;
+        this.alerts = alerts;
+        this.localizationKey = "TERM_COLLECTIONS.";
+        this.tooltipLocalizationKey = "TERM_COLLECTIONS.TOOLTIPS.";
+        this.readyStatus = "Ready";
+        this.collectionErrorStatus = MtCollectionStatus.ERROR;
+    }
+    get selected() {
+        return this.collectionService.selected;
+    }
+    set selected(val) {
+        this.collectionService.selected = val;
+    }
+    get collections() {
+        return this.collectionService?.collections;
+    }
+    get hasAnyCollections() {
+        return this.collectionService.hasAnyCollections;
+    }
+    get isRefreshingCollections() {
+        return this.collectionService?.isRefreshingCollections;
+    }
+    get hasEditPermissions() {
+        return this.collectionService.hasEditPermissions;
+    }
+    get appName() {
+        return this.config.coreConfig.appName;
+    }
+    ngOnInit() {
+        this.subscription = this.tldSystem.getActiveData().subscribe((active) => {
+            this.sourceLanguageCode = active.sourceLang.lang;
+            this.targetLanguageCode = active.targetLang.lang;
+        });
+    }
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
+    }
+    getEditLink(collection) {
+        return `${this.config.termConfig.apiUrl}/collections/${collection.termId}/mt/${this.sourceLanguageCode}/${this.targetLanguageCode}`;
+    }
+    createNew() {
+        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;
+                }
+                const languages = [this.sourceLanguageCode, this.targetLanguageCode];
+                this.collectionService.create(languages, collectionName).subscribe((collection) => {
+                    window.open(this.getEditLink(collection), "_blank");
+                }, (err) => {
+                    console.error(err);
+                    const error = { ErrorCode: ErrorCode.COLLECTION_CREATE };
+                    this.alerts.unhandeledError(error);
+                    throw error;
+                });
+            });
+        });
+    }
+    attach(collection) {
+        this.collectionService.addCollectionToSystem(collection);
+    }
+}
+TldTermCollectionListComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTermCollectionListComponent, deps: [{ token: i1.TldTermCollectionsService }, { token: i2.TldTranslateConfigService }, { token: i3.TldSystemService }, { token: i4.MatDialog }, { token: i5.TranslateService }, { token: i2.TldAlertService }], target: i0.ɵɵFactoryTarget.Component });
+TldTermCollectionListComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: TldTermCollectionListComponent, selector: "tld-term-collection-list", ngImport: i0, template: "<header class=\"tld-collection-list-header\">\r\n  <ng-container *ngIf=\"hasAnyCollections\">\r\n    <h1 class=\"term-window-title\">\r\n      <span fxHide.lt-sm>{{localizationKey + 'TITLE' | translate}}</span>\r\n      <span fxHide.gt-xs>{{localizationKey + 'TITLE_MOBILE' | translate}}</span>\r\n    </h1>\r\n    <p class=\"term-window-description\">\r\n      <span>{{localizationKey + 'DESCRIPTION_1' | translate}}</span>\r\n      <span fxHide.lt-sm *ngIf=\"hasEditPermissions\">{{localizationKey + 'DESCRIPTION_2' | translate}}</span>\r\n      <span fxHide.gt-xs *ngIf=\"hasEditPermissions\">{{localizationKey + 'DESCRIPTION_2_MOBILE' | translate}}</span>\r\n    </p>\r\n  </ng-container>\r\n  <ng-container *ngIf=\"!hasAnyCollections\">\r\n    <h1 class=\"term-window-title\">{{localizationKey + 'TITLE_EMPTY' | translate}}</h1>\r\n    <p class=\"term-window-description\" fxHide.lt-sm>{{localizationKey + 'DESCRIPTION_EMPTY' | translate: {appName: appName} }}</p>\r\n    <p class=\"term-window-description\" fxHide.gt-xs>{{localizationKey + 'DESCRIPTION_EMPTY_MOBILE' | translate: {appName: appName} }}</p>\r\n  </ng-container>\r\n</header>\r\n<div *ngIf=\"hasAnyCollections\" class=\"tld-collection-list-body\">\r\n  <mat-radio-group [attr.aria-label]=\"localizationKey + 'ARIA_LABELS.RADIO_GROUP' | translate\"\r\n    [(ngModel)]=\"selected\">\r\n    <div fxLayout=\"row\" fxLayoutAlign=\"start center\">\r\n      <mat-radio-button [value]=\"null\">\r\n        {{localizationKey + 'SELECTED_NONE' | translate}}\r\n      </mat-radio-button>\r\n    </div>\r\n    <div fxLayout=\"row\" fxLayoutAlign=\"start center\" *ngFor=\"let collection of collections\"\r\n      [matTooltip]=\"collection.tooltipKey? (tooltipLocalizationKey + collection.tooltipKey | translate) : ''\">\r\n      <mat-radio-button [value]=\"collection\" fxFlex\r\n        [disabled]=\"collection.termId !== null && collection.entryCount<=0\" fxLayoutAlign=\"center center\">\r\n        <span class=\"collection-label\" [matTooltip]=\"collection.tooltipKey? '' : collection.title\">\r\n          {{collection.title}}</span>\r\n        <span class=\"collection-label entries-count-label\"\r\n          *ngIf=\"collection.entryCount!==undefined && !collection.mtAttachmentDateTime\"\r\n          [matTooltip]=\"collection.tooltipKey? '' : (tooltipLocalizationKey+'ENTRY_COUNT' | translate)\">\r\n          {{localizationKey + (collection.languagesString?'ENTRY_COUNT_WITH_LANGUGAES':'ENTRY_COUNT') |\r\n          translate: {count: collection.entryCount, languages: collection.languagesString} }}\r\n        </span>\r\n\r\n        <span class=\"collection-label entries-count-label\"\r\n          *ngIf=\"collection.mtEntryCount!==undefined && collection.mtAttachmentDateTime\"\r\n          [matTooltip]=\"collection.tooltipKey? '' : (tooltipLocalizationKey+'MT_ENTRY_COUNT' | translate)\">\r\n          {{localizationKey + ('MT_ENTRY_COUNT') |\r\n          translate: {count: collection.mtEntryCount} }}\r\n        </span>\r\n      </mat-radio-button>\r\n\r\n      <span *ngIf=\" collection.mtStatus === collectionErrorStatus\" color=\"accent\" class=\"material-icons\"\r\n        [matTooltip]=\"(collection.errorKey? 'ERRORS.'+collection.errorKey : tooltipLocalizationKey + 'ATTACH_TO_SYSTEM_ERROR') | translate: { termId: collection.termId} \">\r\n        error\r\n      </span>\r\n\r\n      <mat-spinner color=\"accent\" diameter=\"20\" *ngIf=\"collection.isImporting\"></mat-spinner>\r\n      <ng-container *ngIf=\"hasEditPermissions\">\r\n        <button mat-button *ngIf=\"collection.syncButtonVissible\" (click)=\"attach(collection)\" color=\"primary\"\r\n          [matTooltip]=\"tooltipLocalizationKey + 'SYNC' | translate\" [disabled]=\"collection.isImporting\">\r\n          {{localizationKey + (collectionErrorStatus === collection.mtStatus? 'SYNC_ERROR': 'SYNC') | translate}}\r\n        </button>\r\n        <a mat-button color=\"accent\" target=\"_blank\"\r\n          [matTooltip]=\"collection.tooltipKey? '' : (tooltipLocalizationKey + 'EDIT' | translate)\"\r\n          [attr.href]=\"getEditLink(collection)\" *ngIf=\"collection.termId\" fxHide.lt-sm>\r\n          <span>\r\n            {{localizationKey + 'EDIT' | translate}}\r\n          </span>\r\n        </a>\r\n      </ng-container>\r\n    </div>\r\n  </mat-radio-group>\r\n</div>\r\n<footer class=\"tld-collection-list-footer\" fxLayout=\"row\" *ngIf=\"hasEditPermissions\">\r\n  <button mat-flat-button color=\"primary\" (click)=\"createNew()\" fxHide.lt-sm>\r\n    {{localizationKey + 'CREATE' | translate}}\r\n  </button>\r\n</footer>\r\n", styles: [".tld-collection-list-body,.tld-collection-list-header,.tld-collection-list-footer{padding:1em .75em}.collection-label{display:block;max-width:215px;overflow:hidden;text-overflow:ellipsis}.collection-label.entries-count-label{font-size:small;color:#9aa5b1}:host ::ng-deep .mat-radio-button{overflow:hidden;padding:5px 0}:host ::ng-deep .mat-radio-button .mat-radio-ripple{display:none}:host ::ng-deep .mat-radio-button .mat-radio-label-content{overflow:hidden}\n"], dependencies: [{ kind: "directive", type: i6.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i6.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i7.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i8.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: "component", type: i8.MatAnchor, selector: "a[mat-button], a[mat-raised-button], a[mat-icon-button], a[mat-fab],             a[mat-mini-fab], a[mat-stroked-button], a[mat-flat-button]", inputs: ["disabled", "disableRipple", "color", "tabIndex"], exportAs: ["matButton", "matAnchor"] }, { kind: "directive", type: i9.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }, { kind: "directive", type: i10.MatRadioGroup, selector: "mat-radio-group", exportAs: ["matRadioGroup"] }, { kind: "component", type: i10.MatRadioButton, selector: "mat-radio-button", inputs: ["disableRipple", "tabIndex"], exportAs: ["matRadioButton"] }, { kind: "directive", type: i11.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: "directive", type: i11.DefaultLayoutAlignDirective, selector: "  [fxLayoutAlign], [fxLayoutAlign.xs], [fxLayoutAlign.sm], [fxLayoutAlign.md],  [fxLayoutAlign.lg], [fxLayoutAlign.xl], [fxLayoutAlign.lt-sm], [fxLayoutAlign.lt-md],  [fxLayoutAlign.lt-lg], [fxLayoutAlign.lt-xl], [fxLayoutAlign.gt-xs], [fxLayoutAlign.gt-sm],  [fxLayoutAlign.gt-md], [fxLayoutAlign.gt-lg]", inputs: ["fxLayoutAlign", "fxLayoutAlign.xs", "fxLayoutAlign.sm", "fxLayoutAlign.md", "fxLayoutAlign.lg", "fxLayoutAlign.xl", "fxLayoutAlign.lt-sm", "fxLayoutAlign.lt-md", "fxLayoutAlign.lt-lg", "fxLayoutAlign.lt-xl", "fxLayoutAlign.gt-xs", "fxLayoutAlign.gt-sm", "fxLayoutAlign.gt-md", "fxLayoutAlign.gt-lg"] }, { kind: "directive", type: i11.DefaultFlexDirective, selector: "  [fxFlex], [fxFlex.xs], [fxFlex.sm], [fxFlex.md],  [fxFlex.lg], [fxFlex.xl], [fxFlex.lt-sm], [fxFlex.lt-md],  [fxFlex.lt-lg], [fxFlex.lt-xl], [fxFlex.gt-xs], [fxFlex.gt-sm],  [fxFlex.gt-md], [fxFlex.gt-lg]", inputs: ["fxFlex", "fxFlex.xs", "fxFlex.sm", "fxFlex.md", "fxFlex.lg", "fxFlex.xl", "fxFlex.lt-sm", "fxFlex.lt-md", "fxFlex.lt-lg", "fxFlex.lt-xl", "fxFlex.gt-xs", "fxFlex.gt-sm", "fxFlex.gt-md", "fxFlex.gt-lg"] }, { kind: "directive", type: i12.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: i13.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "diameter", "strokeWidth", "mode", "value"], exportAs: ["matProgressSpinner"] }, { kind: "pipe", type: i5.TranslatePipe, name: "translate" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTermCollectionListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tld-term-collection-list', template: "<header class=\"tld-collection-list-header\">\r\n  <ng-container *ngIf=\"hasAnyCollections\">\r\n    <h1 class=\"term-window-title\">\r\n      <span fxHide.lt-sm>{{localizationKey + 'TITLE' | translate}}</span>\r\n      <span fxHide.gt-xs>{{localizationKey + 'TITLE_MOBILE' | translate}}</span>\r\n    </h1>\r\n    <p class=\"term-window-description\">\r\n      <span>{{localizationKey + 'DESCRIPTION_1' | translate}}</span>\r\n      <span fxHide.lt-sm *ngIf=\"hasEditPermissions\">{{localizationKey + 'DESCRIPTION_2' | translate}}</span>\r\n      <span fxHide.gt-xs *ngIf=\"hasEditPermissions\">{{localizationKey + 'DESCRIPTION_2_MOBILE' | translate}}</span>\r\n    </p>\r\n  </ng-container>\r\n  <ng-container *ngIf=\"!hasAnyCollections\">\r\n    <h1 class=\"term-window-title\">{{localizationKey + 'TITLE_EMPTY' | translate}}</h1>\r\n    <p class=\"term-window-description\" fxHide.lt-sm>{{localizationKey + 'DESCRIPTION_EMPTY' | translate: {appName: appName} }}</p>\r\n    <p class=\"term-window-description\" fxHide.gt-xs>{{localizationKey + 'DESCRIPTION_EMPTY_MOBILE' | translate: {appName: appName} }}</p>\r\n  </ng-container>\r\n</header>\r\n<div *ngIf=\"hasAnyCollections\" class=\"tld-collection-list-body\">\r\n  <mat-radio-group [attr.aria-label]=\"localizationKey + 'ARIA_LABELS.RADIO_GROUP' | translate\"\r\n    [(ngModel)]=\"selected\">\r\n    <div fxLayout=\"row\" fxLayoutAlign=\"start center\">\r\n      <mat-radio-button [value]=\"null\">\r\n        {{localizationKey + 'SELECTED_NONE' | translate}}\r\n      </mat-radio-button>\r\n    </div>\r\n    <div fxLayout=\"row\" fxLayoutAlign=\"start center\" *ngFor=\"let collection of collections\"\r\n      [matTooltip]=\"collection.tooltipKey? (tooltipLocalizationKey + collection.tooltipKey | translate) : ''\">\r\n      <mat-radio-button [value]=\"collection\" fxFlex\r\n        [disabled]=\"collection.termId !== null && collection.entryCount<=0\" fxLayoutAlign=\"center center\">\r\n        <span class=\"collection-label\" [matTooltip]=\"collection.tooltipKey? '' : collection.title\">\r\n          {{collection.title}}</span>\r\n        <span class=\"collection-label entries-count-label\"\r\n          *ngIf=\"collection.entryCount!==undefined && !collection.mtAttachmentDateTime\"\r\n          [matTooltip]=\"collection.tooltipKey? '' : (tooltipLocalizationKey+'ENTRY_COUNT' | translate)\">\r\n          {{localizationKey + (collection.languagesString?'ENTRY_COUNT_WITH_LANGUGAES':'ENTRY_COUNT') |\r\n          translate: {count: collection.entryCount, languages: collection.languagesString} }}\r\n        </span>\r\n\r\n        <span class=\"collection-label entries-count-label\"\r\n          *ngIf=\"collection.mtEntryCount!==undefined && collection.mtAttachmentDateTime\"\r\n          [matTooltip]=\"collection.tooltipKey? '' : (tooltipLocalizationKey+'MT_ENTRY_COUNT' | translate)\">\r\n          {{localizationKey + ('MT_ENTRY_COUNT') |\r\n          translate: {count: collection.mtEntryCount} }}\r\n        </span>\r\n      </mat-radio-button>\r\n\r\n      <span *ngIf=\" collection.mtStatus === collectionErrorStatus\" color=\"accent\" class=\"material-icons\"\r\n        [matTooltip]=\"(collection.errorKey? 'ERRORS.'+collection.errorKey : tooltipLocalizationKey + 'ATTACH_TO_SYSTEM_ERROR') | translate: { termId: collection.termId} \">\r\n        error\r\n      </span>\r\n\r\n      <mat-spinner color=\"accent\" diameter=\"20\" *ngIf=\"collection.isImporting\"></mat-spinner>\r\n      <ng-container *ngIf=\"hasEditPermissions\">\r\n        <button mat-button *ngIf=\"collection.syncButtonVissible\" (click)=\"attach(collection)\" color=\"primary\"\r\n          [matTooltip]=\"tooltipLocalizationKey + 'SYNC' | translate\" [disabled]=\"collection.isImporting\">\r\n          {{localizationKey + (collectionErrorStatus === collection.mtStatus? 'SYNC_ERROR': 'SYNC') | translate}}\r\n        </button>\r\n        <a mat-button color=\"accent\" target=\"_blank\"\r\n          [matTooltip]=\"collection.tooltipKey? '' : (tooltipLocalizationKey + 'EDIT' | translate)\"\r\n          [attr.href]=\"getEditLink(collection)\" *ngIf=\"collection.termId\" fxHide.lt-sm>\r\n          <span>\r\n            {{localizationKey + 'EDIT' | translate}}\r\n          </span>\r\n        </a>\r\n      </ng-container>\r\n    </div>\r\n  </mat-radio-group>\r\n</div>\r\n<footer class=\"tld-collection-list-footer\" fxLayout=\"row\" *ngIf=\"hasEditPermissions\">\r\n  <button mat-flat-button color=\"primary\" (click)=\"createNew()\" fxHide.lt-sm>\r\n    {{localizationKey + 'CREATE' | translate}}\r\n  </button>\r\n</footer>\r\n", styles: [".tld-collection-list-body,.tld-collection-list-header,.tld-collection-list-footer{padding:1em .75em}.collection-label{display:block;max-width:215px;overflow:hidden;text-overflow:ellipsis}.collection-label.entries-count-label{font-size:small;color:#9aa5b1}:host ::ng-deep .mat-radio-button{overflow:hidden;padding:5px 0}:host ::ng-deep .mat-radio-button .mat-radio-ripple{display:none}:host ::ng-deep .mat-radio-button .mat-radio-label-content{overflow:hidden}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.TldTermCollectionsService }, { type: i2.TldTranslateConfigService }, { type: i3.TldSystemService }, { type: i4.MatDialog }, { type: i5.TranslateService }, { type: i2.TldAlertService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tld-term-collection-list.component.js","sourceRoot":"","sources":["../../../../../../../projects/tld-translate/src/lib/modules/tld-term/tld-term-collection-list/tld-term-collection-list.component.ts","../../../../../../../projects/tld-translate/src/lib/modules/tld-term/tld-term-collection-list/tld-term-collection-list.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnDestroy, OnInit } from '@angular/core';\r\nimport { MatDialog } from '@angular/material/dialog';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { Subscription } from 'rxjs';\r\nimport { ErrorCode } from '../../tld-common/models/errors/error-codes.enum';\r\nimport { TldAlertService, TldTranslateConfigService } from '../../tld-common/services';\r\nimport { TldSystemService } from '../../tld-tooltip/services';\r\nimport { MtCollectionStatus } from '../models/mt-collection-status.model';\r\nimport { TldConvertedCollection } from '../models/tld-converted-collection.model';\r\nimport { TldTermCollectionsService } from '../services/tld-term-collections.service';\r\nimport { TldTermCreateCollectionDialogComponent } from '../tld-term-create-collection-dialog/tld-term-create-collection-dialog.component';\r\n\r\n@Component({\r\n  selector: 'tld-term-collection-list',\r\n  templateUrl: './tld-term-collection-list.component.html',\r\n  styleUrls: ['./tld-term-collection-list.component.scss']\r\n})\r\nexport class TldTermCollectionListComponent implements OnInit, OnDestroy {\r\n  get selected() {\r\n    return this.collectionService.selected;\r\n  }\r\n\r\n  set selected(val: TldConvertedCollection) {\r\n    this.collectionService.selected = val;\r\n  }\r\n\r\n  get collections() {\r\n    return this.collectionService?.collections;\r\n  }\r\n\r\n  get hasAnyCollections() {\r\n    return this.collectionService.hasAnyCollections;\r\n  }\r\n\r\n  get isRefreshingCollections() {\r\n    return this.collectionService?.isRefreshingCollections;\r\n  }\r\n\r\n  get hasEditPermissions() {\r\n    return this.collectionService.hasEditPermissions;\r\n  }\r\n\r\n  get appName() {\r\n    return this.config.coreConfig.appName;\r\n  }\r\n\r\n  readonly localizationKey = \"TERM_COLLECTIONS.\";\r\n  readonly tooltipLocalizationKey = \"TERM_COLLECTIONS.TOOLTIPS.\";\r\n  readonly readyStatus = \"Ready\";\r\n  private sourceLanguageCode: string;\r\n  private targetLanguageCode: string;\r\n  private subscription: Subscription;\r\n\r\n  readonly collectionErrorStatus = MtCollectionStatus.ERROR;\r\n\r\n  constructor(private readonly collectionService: TldTermCollectionsService,\r\n    private readonly config: TldTranslateConfigService,\r\n    private readonly tldSystem: TldSystemService,\r\n    private readonly dialog: MatDialog,\r\n    private readonly translate: TranslateService,\r\n    private readonly alerts: TldAlertService) {\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.subscription = this.tldSystem.getActiveData().subscribe((active) => {\r\n      this.sourceLanguageCode = active.sourceLang.lang;\r\n      this.targetLanguageCode = active.targetLang.lang;\r\n    })\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.subscription.unsubscribe();\r\n  }\r\n\r\n  getEditLink(collection: TldConvertedCollection) {\r\n    return `${this.config.termConfig.apiUrl}/collections/${collection.termId}/mt/${this.sourceLanguageCode}/${this.targetLanguageCode}`;\r\n  }\r\n\r\n  createNew() {\r\n    const localizationKey = \"TERM_COLLECTIONS.DEFAULT_COLLECTION_NAME\";\r\n    this.translate.get(localizationKey).subscribe((collectionName) => {\r\n      const dialogRef = this.dialog.open(TldTermCreateCollectionDialogComponent, {\r\n        minWidth: '300px',\r\n        maxWidth: '700px',\r\n        data: { collectionName: collectionName }\r\n      });\r\n      dialogRef.afterClosed().subscribe(collectionName => {\r\n        if (!collectionName) {\r\n          return;\r\n        }\r\n\r\n        const languages = [this.sourceLanguageCode, this.targetLanguageCode];\r\n        this.collectionService.create(languages, collectionName).subscribe((collection) => {\r\n          window.open(this.getEditLink(collection), \"_blank\");\r\n        },\r\n          (err) => {\r\n            console.error(err);\r\n            const error = { ErrorCode: ErrorCode.COLLECTION_CREATE };\r\n            this.alerts.unhandeledError(error);\r\n            throw error;\r\n          });\r\n      });\r\n    });\r\n  }\r\n\r\n  attach(collection: TldConvertedCollection) {\r\n    this.collectionService.addCollectionToSystem(collection);\r\n  }\r\n}\r\n","<header class=\"tld-collection-list-header\">\r\n  <ng-container *ngIf=\"hasAnyCollections\">\r\n    <h1 class=\"term-window-title\">\r\n      <span fxHide.lt-sm>{{localizationKey + 'TITLE' | translate}}</span>\r\n      <span fxHide.gt-xs>{{localizationKey + 'TITLE_MOBILE' | translate}}</span>\r\n    </h1>\r\n    <p class=\"term-window-description\">\r\n      <span>{{localizationKey + 'DESCRIPTION_1' | translate}}</span>\r\n      <span fxHide.lt-sm *ngIf=\"hasEditPermissions\">{{localizationKey + 'DESCRIPTION_2' | translate}}</span>\r\n      <span fxHide.gt-xs *ngIf=\"hasEditPermissions\">{{localizationKey + 'DESCRIPTION_2_MOBILE' | translate}}</span>\r\n    </p>\r\n  </ng-container>\r\n  <ng-container *ngIf=\"!hasAnyCollections\">\r\n    <h1 class=\"term-window-title\">{{localizationKey + 'TITLE_EMPTY' | translate}}</h1>\r\n    <p class=\"term-window-description\" fxHide.lt-sm>{{localizationKey + 'DESCRIPTION_EMPTY' | translate: {appName: appName} }}</p>\r\n    <p class=\"term-window-description\" fxHide.gt-xs>{{localizationKey + 'DESCRIPTION_EMPTY_MOBILE' | translate: {appName: appName} }}</p>\r\n  </ng-container>\r\n</header>\r\n<div *ngIf=\"hasAnyCollections\" class=\"tld-collection-list-body\">\r\n  <mat-radio-group [attr.aria-label]=\"localizationKey + 'ARIA_LABELS.RADIO_GROUP' | translate\"\r\n    [(ngModel)]=\"selected\">\r\n    <div fxLayout=\"row\" fxLayoutAlign=\"start center\">\r\n      <mat-radio-button [value]=\"null\">\r\n        {{localizationKey + 'SELECTED_NONE' | translate}}\r\n      </mat-radio-button>\r\n    </div>\r\n    <div fxLayout=\"row\" fxLayoutAlign=\"start center\" *ngFor=\"let collection of collections\"\r\n      [matTooltip]=\"collection.tooltipKey? (tooltipLocalizationKey + collection.tooltipKey | translate) : ''\">\r\n      <mat-radio-button [value]=\"collection\" fxFlex\r\n        [disabled]=\"collection.termId !== null && collection.entryCount<=0\" fxLayoutAlign=\"center center\">\r\n        <span class=\"collection-label\" [matTooltip]=\"collection.tooltipKey? '' : collection.title\">\r\n          {{collection.title}}</span>\r\n        <span class=\"collection-label entries-count-label\"\r\n          *ngIf=\"collection.entryCount!==undefined && !collection.mtAttachmentDateTime\"\r\n          [matTooltip]=\"collection.tooltipKey? '' : (tooltipLocalizationKey+'ENTRY_COUNT' | translate)\">\r\n          {{localizationKey + (collection.languagesString?'ENTRY_COUNT_WITH_LANGUGAES':'ENTRY_COUNT') |\r\n          translate: {count: collection.entryCount, languages: collection.languagesString} }}\r\n        </span>\r\n\r\n        <span class=\"collection-label entries-count-label\"\r\n          *ngIf=\"collection.mtEntryCount!==undefined && collection.mtAttachmentDateTime\"\r\n          [matTooltip]=\"collection.tooltipKey? '' : (tooltipLocalizationKey+'MT_ENTRY_COUNT' | translate)\">\r\n          {{localizationKey + ('MT_ENTRY_COUNT') |\r\n          translate: {count: collection.mtEntryCount} }}\r\n        </span>\r\n      </mat-radio-button>\r\n\r\n      <span *ngIf=\" collection.mtStatus === collectionErrorStatus\" color=\"accent\" class=\"material-icons\"\r\n        [matTooltip]=\"(collection.errorKey? 'ERRORS.'+collection.errorKey : tooltipLocalizationKey + 'ATTACH_TO_SYSTEM_ERROR') | translate: { termId: collection.termId} \">\r\n        error\r\n      </span>\r\n\r\n      <mat-spinner color=\"accent\" diameter=\"20\" *ngIf=\"collection.isImporting\"></mat-spinner>\r\n      <ng-container *ngIf=\"hasEditPermissions\">\r\n        <button mat-button *ngIf=\"collection.syncButtonVissible\" (click)=\"attach(collection)\" color=\"primary\"\r\n          [matTooltip]=\"tooltipLocalizationKey + 'SYNC' | translate\" [disabled]=\"collection.isImporting\">\r\n          {{localizationKey + (collectionErrorStatus === collection.mtStatus? 'SYNC_ERROR': 'SYNC') | translate}}\r\n        </button>\r\n        <a mat-button color=\"accent\" target=\"_blank\"\r\n          [matTooltip]=\"collection.tooltipKey? '' : (tooltipLocalizationKey + 'EDIT' | translate)\"\r\n          [attr.href]=\"getEditLink(collection)\" *ngIf=\"collection.termId\" fxHide.lt-sm>\r\n          <span>\r\n            {{localizationKey + 'EDIT' | translate}}\r\n          </span>\r\n        </a>\r\n      </ng-container>\r\n    </div>\r\n  </mat-radio-group>\r\n</div>\r\n<footer class=\"tld-collection-list-footer\" fxLayout=\"row\" *ngIf=\"hasEditPermissions\">\r\n  <button mat-flat-button color=\"primary\" (click)=\"createNew()\" fxHide.lt-sm>\r\n    {{localizationKey + 'CREATE' | translate}}\r\n  </button>\r\n</footer>\r\n"]}

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

@@ -0,0 +1,47 @@
+import { Component, Inject } from '@angular/core';
+import { UntypedFormControl, UntypedFormGroup, Validators } from '@angular/forms';
+import { MAT_DIALOG_DATA } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "../../tld-common/services";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/material/button";
+import * as i6 from "@angular/material/form-field";
+import * as i7 from "@angular/material/input";
+import * as i8 from "@angular/flex-layout/flex";
+import * as i9 from "@tilde-nlp/ngx-common";
+import * as i10 from "@ngx-translate/core";
+export class TldTermCreateCollectionDialogComponent {
+    constructor(dialogRef, data, config) {
+        this.dialogRef = dialogRef;
+        this.data = data;
+        this.config = config;
+    }
+    ngOnInit() {
+        this.minLength = this.config.termConfig.collectionNameMinLength;
+        this.maxLength = this.config.termConfig.collectionNameMaxLength;
+        this.collectionName = new UntypedFormControl(this.data.collectionName, [
+            Validators.minLength(this.minLength),
+            Validators.maxLength(this.maxLength),
+            Validators.required
+        ]);
+        this.collectionName.markAsTouched();
+        this.formGroup = new UntypedFormGroup({ collectionName: this.collectionName });
+    }
+    submit() {
+        if (this.formGroup.valid) {
+            this.dialogRef.close(this.collectionName.value);
+        }
+    }
+}
+TldTermCreateCollectionDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTermCreateCollectionDialogComponent, deps: [{ token: i1.MatDialogRef }, { token: MAT_DIALOG_DATA }, { token: i2.TldTranslateConfigService }], target: i0.ɵɵFactoryTarget.Component });
+TldTermCreateCollectionDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: TldTermCreateCollectionDialogComponent, selector: "tld-term-create-collection-dialog", ngImport: i0, template: "<tld-close-button class=\"close-button\" mat-dialog-close>\r\n</tld-close-button>\r\n<h1 mat-dialog-title>{{'TERM_COLLECTIONS.CREATE_DIALOG.TITLE' | translate}}</h1>\r\n<div mat-dialog-content>\r\n    <p [innerHtml]=\"'TERM_COLLECTIONS.CREATE_DIALOG.DESCRIPTION_1' | translate\"></p>\r\n    <p [innerHtml]=\"'TERM_COLLECTIONS.CREATE_DIALOG.DESCRIPTION_2' | translate\"></p>\r\n    <div [formGroup]=\"formGroup\">\r\n        <mat-form-field appearance=\"outline\" class=\"collection-name-form-field\">\r\n            <mat-label>{{'TERM_COLLECTIONS.CREATE_DIALOG.COLLECTION_NAME_LABEL' | translate}}</mat-label>\r\n            <input matInput formControlName=\"collectionName\" (keyup.enter)=\"submit()\">\r\n            <mat-error *ngIf=\"collectionName.errors\">{{'TERM_COLLECTIONS.CREATE_DIALOG.COLLECTION_NAME_ERROR' |\r\n                translate: {minLength: minLength, maxLength: maxLength} }}</mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n</div>\r\n<div mat-dialog-actions fxLayout=\"row\" fxLayoutAlign=\"center center\">\r\n    <button mat-flat-button (click)=\"submit()\" cdkFocusInitial color=\"accent\"\r\n        [disabled]=\"formGroup.invalid\">{{'TERM_COLLECTIONS.CREATE_DIALOG.CREATE' | translate}}</button>\r\n    <button mat-button mat-dialog-close color=\"accent\">{{\"TERM_COLLECTIONS.CREATE_DIALOG.CANCEL\" | translate}}</button>\r\n</div>\r\n", styles: ["input{outline:none!important}:host ::ng-deep .mat-form-field-appearance-outline:hover .mat-form-field-outline,:host ::ng-deep .mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick,:host ::ng-deep .mat-form-field.mat-focused .mat-form-field-label{color:#ad234a}.create-dialog-wrapper{position:relative}.close-button{position:absolute;right:1em;top:1em}\n"], dependencies: [{ kind: "directive", type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i5.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: i6.MatError, selector: "mat-error", inputs: ["id"] }, { kind: "component", type: i6.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i6.MatLabel, selector: "mat-label" }, { kind: "directive", type: i7.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "directive", type: i1.MatDialogClose, selector: "[mat-dialog-close], [matDialogClose]", inputs: ["aria-label", "type", "mat-dialog-close", "matDialogClose"], exportAs: ["matDialogClose"] }, { kind: "directive", type: i1.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { kind: "directive", type: i1.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { kind: "directive", type: i1.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]", inputs: ["align"] }, { kind: "directive", type: i8.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: "directive", type: i8.DefaultLayoutAlignDirective, selector: "  [fxLayoutAlign], [fxLayoutAlign.xs], [fxLayoutAlign.sm], [fxLayoutAlign.md],  [fxLayoutAlign.lg], [fxLayoutAlign.xl], [fxLayoutAlign.lt-sm], [fxLayoutAlign.lt-md],  [fxLayoutAlign.lt-lg], [fxLayoutAlign.lt-xl], [fxLayoutAlign.gt-xs], [fxLayoutAlign.gt-sm],  [fxLayoutAlign.gt-md], [fxLayoutAlign.gt-lg]", inputs: ["fxLayoutAlign", "fxLayoutAlign.xs", "fxLayoutAlign.sm", "fxLayoutAlign.md", "fxLayoutAlign.lg", "fxLayoutAlign.xl", "fxLayoutAlign.lt-sm", "fxLayoutAlign.lt-md", "fxLayoutAlign.lt-lg", "fxLayoutAlign.lt-xl", "fxLayoutAlign.gt-xs", "fxLayoutAlign.gt-sm", "fxLayoutAlign.gt-md", "fxLayoutAlign.gt-lg"] }, { kind: "directive", type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i3.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "component", type: i9.CloseButtonComponent, selector: "tld-close-button", inputs: ["ariaCode", "disabled", "tooltip"], outputs: ["tldClick"] }, { kind: "pipe", type: i10.TranslatePipe, name: "translate" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TldTermCreateCollectionDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tld-term-create-collection-dialog', template: "<tld-close-button class=\"close-button\" mat-dialog-close>\r\n</tld-close-button>\r\n<h1 mat-dialog-title>{{'TERM_COLLECTIONS.CREATE_DIALOG.TITLE' | translate}}</h1>\r\n<div mat-dialog-content>\r\n    <p [innerHtml]=\"'TERM_COLLECTIONS.CREATE_DIALOG.DESCRIPTION_1' | translate\"></p>\r\n    <p [innerHtml]=\"'TERM_COLLECTIONS.CREATE_DIALOG.DESCRIPTION_2' | translate\"></p>\r\n    <div [formGroup]=\"formGroup\">\r\n        <mat-form-field appearance=\"outline\" class=\"collection-name-form-field\">\r\n            <mat-label>{{'TERM_COLLECTIONS.CREATE_DIALOG.COLLECTION_NAME_LABEL' | translate}}</mat-label>\r\n            <input matInput formControlName=\"collectionName\" (keyup.enter)=\"submit()\">\r\n            <mat-error *ngIf=\"collectionName.errors\">{{'TERM_COLLECTIONS.CREATE_DIALOG.COLLECTION_NAME_ERROR' |\r\n                translate: {minLength: minLength, maxLength: maxLength} }}</mat-error>\r\n        </mat-form-field>\r\n    </div>\r\n</div>\r\n<div mat-dialog-actions fxLayout=\"row\" fxLayoutAlign=\"center center\">\r\n    <button mat-flat-button (click)=\"submit()\" cdkFocusInitial color=\"accent\"\r\n        [disabled]=\"formGroup.invalid\">{{'TERM_COLLECTIONS.CREATE_DIALOG.CREATE' | translate}}</button>\r\n    <button mat-button mat-dialog-close color=\"accent\">{{\"TERM_COLLECTIONS.CREATE_DIALOG.CANCEL\" | translate}}</button>\r\n</div>\r\n", styles: ["input{outline:none!important}:host ::ng-deep .mat-form-field-appearance-outline:hover .mat-form-field-outline,:host ::ng-deep .mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick,:host ::ng-deep .mat-form-field.mat-focused .mat-form-field-label{color:#ad234a}.create-dialog-wrapper{position:relative}.close-button{position:absolute;right:1em;top:1em}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialogRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }, { type: i2.TldTranslateConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,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