@netgrif/components-core 6.3.0 → 6.4.0-beta.2

package/esm2020/lib/data-fields/file-list-field/file-list-default-field/abstract-file-list-default-field.component.mjs

@@ -0,0 +1,304 @@
+import { Component, Inject, Input, Optional, ViewChild } from "@angular/core";
+import { DATA_FIELD_PORTAL_DATA } from "../../models/data-field-portal-data-injection-token";
+import { FileListFieldValidation } from "../models/file-list-field";
+import { ProgressType } from "../../../resources/resource-provider.service";
+import { HttpParams } from "@angular/common/http";
+import { take } from "rxjs/operators";
+import { AbstractBaseDataFieldComponent } from "../../base-component/abstract-base-data-field.component";
+import * as i0 from "@angular/core";
+import * as i1 from "../../../resources/engine-endpoint/task-resource.service";
+import * as i2 from "../../../logger/services/logger.service";
+import * as i3 from "../../../snack-bar/services/snack-bar.service";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "../../../event/services/event.service";
+export class AbstractFileListDefaultFieldComponent extends AbstractBaseDataFieldComponent {
+    constructor(_taskResourceService, _log, _snackbar, _translate, _eventService, dataFieldPortalData) {
+        super(dataFieldPortalData);
+        this._taskResourceService = _taskResourceService;
+        this._log = _log;
+        this._snackbar = _snackbar;
+        this._translate = _translate;
+        this._eventService = _eventService;
+        this.state = this.defaultState;
+        this.uploadedFiles = new Array();
+        this.maxFilesNumber = Number.POSITIVE_INFINITY;
+        this.taskId = dataFieldPortalData.additionalFieldProperties.taskId;
+    }
+    ngOnInit() {
+        this.valueChange$ = this.dataField.valueChanges().subscribe(() => {
+            this.parseResponse();
+        });
+        if (this.dataField.validations && this.dataField.validations.length !== 0) {
+            const val = this.dataField.validations.find(validation => validation.validationRule.includes(FileListFieldValidation.MAX_FILES));
+            if (val && val.validationRule.split(' ').length === 2 && !isNaN(parseInt(val.validationRule.split(' ')[1], 10))) {
+                this.maxFilesNumber = parseInt(val.validationRule.split(' ')[1], 10);
+                this.maxFilesMessage = val.validationMessage && val.validationMessage !== '' ? val.validationMessage : null;
+            }
+        }
+    }
+    /**
+     * Set file picker and image elements to [FileFieldService]{@link FileFieldService}.
+     *
+     * Initialize file image.
+     */
+    ngAfterViewInit() {
+        if (this.fileUploadEl) {
+            this.fileUploadEl.nativeElement.onchange = () => {
+                this.upload();
+            };
+        }
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.valueChange$.unsubscribe();
+    }
+    chooseFile() {
+        if (this.state.uploading || this.formControlRef.disabled) {
+            return;
+        }
+        this.fileUploadEl.nativeElement.click();
+    }
+    /**
+     * Call after click on file field.
+     *
+     * If file field has no file uploaded
+     * [FilesUploadComponent]{@link AbstractFilesUploadComponent} via [SideMenu]{@link SideMenuService} opens.
+     *
+     * Otherwise opens a file picker from which the user can select files.
+     */
+    upload() {
+        if (!this.fileUploadEl.nativeElement.files || this.fileUploadEl.nativeElement.files.length === 0) {
+            return;
+        }
+        if (!this.taskId) {
+            this._log.error('File cannot be uploaded. No task is set to the field.');
+            return;
+        }
+        if (this.fileUploadEl.nativeElement.files.length + this.uploadedFiles.length > this.maxFilesNumber) {
+            this._snackbar.openErrorSnackBar(this.maxFilesMessage ? this.maxFilesMessage :
+                this._translate.instant('dataField.snackBar.maxFilesExceeded') + this.maxFilesNumber);
+            this.fileUploadEl.nativeElement.value = '';
+            return;
+        }
+        let filesToUpload = Array.from(this.fileUploadEl.nativeElement.files);
+        let sum = 0;
+        filesToUpload.forEach(item => sum += item.size);
+        if (this.dataField.maxUploadSizeInBytes &&
+            this.dataField.maxUploadSizeInBytes < sum) {
+            this._log.error('Files cannot be uploaded. Maximum size of files exceeded.');
+            this._snackbar.openErrorSnackBar(this._translate.instant('dataField.snackBar.maxFilesSizeExceeded') + this.dataField.maxUploadSizeInBytes);
+            this.fileUploadEl.nativeElement.value = '';
+            return;
+        }
+        if (this.dataField.value && this.dataField.value.namesPaths && this.dataField.value.namesPaths.length !== 0) {
+            this.dataField.value.namesPaths.forEach(namePath => {
+                filesToUpload = filesToUpload.filter(fileToUpload => fileToUpload.name !== namePath.name);
+            });
+            if (filesToUpload.length === 0) {
+                this._log.error('User chose the same files that are already uploaded. Uploading skipped');
+                this._snackbar.openErrorSnackBar(this._translate.instant('dataField.snackBar.wontUploadSameFiles'));
+                this.fileUploadEl.nativeElement.value = '';
+                return;
+            }
+        }
+        this.state = this.defaultState;
+        this.state.uploading = true;
+        const fileFormData = new FormData();
+        filesToUpload.forEach(fileToUpload => {
+            fileFormData.append('files', fileToUpload);
+        });
+        const data = {};
+        data[this.resolveParentTaskId()] = this.dataField.stringId;
+        fileFormData.append('data', new Blob([JSON.stringify(data)], { type: 'application/json' }));
+        this._taskResourceService.uploadFile(this.taskId, this.dataField.stringId, fileFormData, true)
+            .subscribe((response) => {
+            if (response.type && response.type === ProgressType.UPLOAD) {
+                this.state.progress = response.progress;
+            }
+            else {
+                this.state.completed = true;
+                this.state.uploading = false;
+                this.state.progress = 0;
+                this._log.debug(`Files [${this.dataField.stringId}] were successfully uploaded`);
+                if (response.error) {
+                    this.state.error = true;
+                    this._log.error(`File [${this.dataField.stringId}] ${this.fileUploadEl.nativeElement.files.item(0)} uploading has failed!`, response.error);
+                    if (response.error) {
+                        this._snackbar.openErrorSnackBar(this._translate.instant(response.error));
+                    }
+                    else {
+                        this._snackbar.openErrorSnackBar(this._translate.instant('dataField.snackBar.fileUploadFailed'));
+                    }
+                }
+                else {
+                    const changedFieldsMap = this._eventService.parseChangedFieldsFromOutcomeTree(response.outcome);
+                    this.dataField.emitChangedFields(changedFieldsMap);
+                    this.state.error = false;
+                    filesToUpload.forEach(fileToUpload => {
+                        this.uploadedFiles.push(fileToUpload.name);
+                        this.dataField.value.namesPaths.push({ name: fileToUpload.name });
+                        this.formControlRef.setValue(this.dataField.value.namesPaths.map(namePath => {
+                            return namePath['name'];
+                        }).join('/'));
+                    });
+                }
+                this.dataField.touch = true;
+                this.dataField.update();
+                this.fileUploadEl.nativeElement.value = '';
+            }
+        }, error => {
+            this.state.completed = true;
+            this.state.error = true;
+            this.state.uploading = false;
+            this.state.progress = 0;
+            if (error?.error?.message) {
+                this._snackbar.openErrorSnackBar(this._translate.instant(error.error.message));
+            }
+            else {
+                this._snackbar.openErrorSnackBar(this._translate.instant('dataField.snackBar.fileUploadFailed'));
+            }
+            this._log.error(`File [${this.dataField.stringId}] ${this.fileUploadEl.nativeElement.files.item(0)} uploading has failed!`, error);
+            this.dataField.touch = true;
+            this.dataField.update();
+            this.fileUploadEl.nativeElement.value = '';
+        });
+    }
+    download(fileName) {
+        if (!this.dataField.value || !this.dataField.value.namesPaths ||
+            !this.dataField.value.namesPaths.find(namePath => namePath.name === fileName)) {
+            return;
+        }
+        if (!this.taskId) {
+            this._log.error('File cannot be downloaded. No task is set to the field.');
+            return;
+        }
+        this.state = this.defaultState;
+        this.state.downloading = true;
+        this._taskResourceService.downloadFile(this.resolveParentTaskId(), this.dataField.stringId, fileName).subscribe(response => {
+            if (response.type && response.type === ProgressType.DOWNLOAD) {
+                this.state.progress = response.progress;
+            }
+            else {
+                this._log.debug(`File [${this.dataField.stringId}] ${fileName} was successfully downloaded`);
+                this.downloadViaAnchor(response, fileName);
+                this.state.downloading = false;
+                this.state.progress = 0;
+                this.dataField.downloaded.push(fileName);
+            }
+        }, error => {
+            this._log.error(`Downloading file [${this.dataField.stringId}] ${fileName} has failed!`, error);
+            this._snackbar.openErrorSnackBar(fileName + ' ' + this._translate.instant('dataField.snackBar.downloadFail'));
+            this.state.downloading = false;
+            this.state.progress = 0;
+        });
+    }
+    downloadViaAnchor(blob, fileName) {
+        const a = document.createElement('a');
+        document.body.appendChild(a);
+        a.setAttribute('style', 'display: none');
+        blob = new Blob([blob], { type: 'application/octet-stream' });
+        const url = window.URL.createObjectURL(blob);
+        a.href = url;
+        a.download = fileName;
+        a.click();
+        window.URL.revokeObjectURL(url);
+        document.body.removeChild(a);
+    }
+    deleteFile(fileName) {
+        if (!this.dataField.value || !this.dataField.value.namesPaths ||
+            !this.dataField.value.namesPaths.find(namePath => namePath.name === fileName)) {
+            return;
+        }
+        if (!this.taskId) {
+            this._log.error('File cannot be deleted. No task is set to the field.');
+            return;
+        }
+        let param = new HttpParams();
+        param = param.set("parentTaskId", this.resolveParentTaskId());
+        this._taskResourceService.deleteFile(this.taskId, this.dataField.stringId, fileName, param).pipe(take(1)).subscribe((response) => {
+            if (response.success) {
+                const changedFieldsMap = this._eventService.parseChangedFieldsFromOutcomeTree(response.outcome);
+                this.dataField.emitChangedFields(changedFieldsMap);
+                this.fileUploadEl.nativeElement.value = '';
+                this.uploadedFiles = this.uploadedFiles.filter(uploadedFile => uploadedFile !== fileName);
+                if (this.dataField.value.namesPaths) {
+                    this.dataField.value.namesPaths = this.dataField.value.namesPaths.filter(namePath => namePath.name !== fileName);
+                    this.formControlRef.setValue(this.dataField.value.namesPaths.map(namePath => {
+                        return namePath['name'];
+                    }).join('/'));
+                    this.dataField.update();
+                }
+                this.dataField.downloaded = this.dataField.downloaded.filter(one => one !== fileName);
+                this._log.debug(`File [${this.dataField.stringId}] ${fileName} was successfully deleted`);
+                this.formControlRef.markAsTouched();
+            }
+            else {
+                this._log.error(`Deleting file [${this.dataField.stringId}] ${fileName} has failed!`, response.error);
+                this._snackbar.openErrorSnackBar(fileName + ' ' + this._translate.instant('dataField.snackBar.fileDeleteFailed'));
+            }
+        });
+    }
+    get defaultState() {
+        return {
+            progress: 0,
+            completed: false,
+            error: false,
+            uploading: false,
+            downloading: false
+        };
+    }
+    /**
+     * Construct display name.
+     */
+    constructDisplayName() {
+        if (!!this.dataField && !!this.dataField.placeholder) {
+            return this.dataField.placeholder;
+        }
+        return this._translate.instant('dataField.file.noFile');
+    }
+    parseResponse() {
+        if (this.dataField.value) {
+            if (!!this.dataField.value.namesPaths && this.dataField.value.namesPaths.length !== 0) {
+                this.uploadedFiles = new Array();
+                this.dataField.value.namesPaths.forEach(namePath => {
+                    this.uploadedFiles.push(namePath.name);
+                });
+            }
+            else {
+                this.dataField.value.namesPaths = new Array();
+            }
+            this.uploadedFiles = this.dataField.value.namesPaths.map(namePath => namePath.name);
+        }
+    }
+    resolveParentTaskId() {
+        return !!this.dataField.parentTaskId ? this.dataField.parentTaskId : this.taskId;
+    }
+    getCutProperty(i18nLabel) {
+        if (this.labelWidth !== i18nLabel.offsetWidth) {
+            this.labelWidth = i18nLabel.offsetWidth;
+            const calculatedWidth = 'calc(0.5em + ' + i18nLabel.offsetWidth / 4 * 3 + 'px)';
+            this.cutProperty = `polygon(0 0, 0 100%, 100% 100%, 100% 0%, ${calculatedWidth} 0, ${calculatedWidth} 3px, 0.5em 3px, 0.5em 0)`;
+        }
+        return this.cutProperty;
+    }
+}
+AbstractFileListDefaultFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AbstractFileListDefaultFieldComponent, deps: [{ token: i1.TaskResourceService }, { token: i2.LoggerService }, { token: i3.SnackBarService }, { token: i4.TranslateService }, { token: i5.EventService }, { token: DATA_FIELD_PORTAL_DATA, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+AbstractFileListDefaultFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: AbstractFileListDefaultFieldComponent, selector: "ncc-abstract-file-list-default-field", inputs: { taskId: "taskId" }, viewQueries: [{ propertyName: "fileUploadEl", first: true, predicate: ["fileUploadInput"], descendants: true }], usesInheritance: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AbstractFileListDefaultFieldComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ncc-abstract-file-list-default-field',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TaskResourceService }, { type: i2.LoggerService }, { type: i3.SnackBarService }, { type: i4.TranslateService }, { type: i5.EventService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DATA_FIELD_PORTAL_DATA]
+                }] }]; }, propDecorators: { taskId: [{
+                type: Input
+            }], fileUploadEl: [{
+                type: ViewChild,
+                args: ['fileUploadInput']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-file-list-default-field.component.js","sourceRoot":"","sources":["../../../../../../../projects/netgrif-components-core/src/lib/data-fields/file-list-field/file-list-default-field/abstract-file-list-default-field.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterViewInit,\n    Component,\n    ElementRef,\n    Inject,\n    Input,\n    OnDestroy,\n    OnInit,\n    Optional,\n    ViewChild\n} from \"@angular/core\";\nimport {DATA_FIELD_PORTAL_DATA, DataFieldPortalData} from \"../../models/data-field-portal-data-injection-token\";\nimport {FileListField, FileListFieldValidation} from \"../models/file-list-field\";\nimport {Subscription} from \"rxjs\";\nimport {TaskResourceService} from \"../../../resources/engine-endpoint/task-resource.service\";\nimport {LoggerService} from \"../../../logger/services/logger.service\";\nimport {SnackBarService} from \"../../../snack-bar/services/snack-bar.service\";\nimport {TranslateService} from \"@ngx-translate/core\";\nimport {EventService} from \"../../../event/services/event.service\";\nimport {FileFieldIdBody} from \"../../models/file-field-id-body\";\nimport {EventOutcomeMessageResource} from \"../../../resources/interface/message-resource\";\nimport {ProgressType, ProviderProgress} from \"../../../resources/resource-provider.service\";\nimport {ChangedFieldsMap} from \"../../../event/services/interfaces/changed-fields-map\";\nimport {HttpParams} from \"@angular/common/http\";\nimport {take} from \"rxjs/operators\";\nimport {FileFieldValue} from \"../../file-field/models/file-field-value\";\nimport {AbstractBaseDataFieldComponent} from \"../../base-component/abstract-base-data-field.component\";\n\nexport interface FilesState {\n    progress: number;\n    uploading: boolean;\n    downloading: boolean;\n    completed: boolean;\n    error: boolean;\n}\n\n\n@Component({\n    selector: 'ncc-abstract-file-list-default-field',\n    template: ''\n})\nexport abstract class AbstractFileListDefaultFieldComponent extends AbstractBaseDataFieldComponent<FileListField> implements OnInit, AfterViewInit, OnDestroy {\n\n    private labelWidth: number;\n    public cutProperty: string;\n    public uploadedFiles: Array<string>;\n    public state: FilesState;\n    private valueChange$: Subscription;\n\n    /**\n     * Values from file list field validation (eg. maxFiles 5)\n     * maxFilesNumber - maximum uploadable files\n     * maxFilesMessage - error message if number of files is exceeded\n     */\n    protected maxFilesNumber: number;\n    protected maxFilesMessage: string;\n\n    /**\n     * Task mongo string id is binding property from parent component.\n     */\n    @Input() public taskId: string;\n\n    /**\n     * File picker element reference from component template that is initialized after view init.\n     */\n    @ViewChild('fileUploadInput') public fileUploadEl: ElementRef<HTMLInputElement>;\n\n    protected constructor(protected _taskResourceService: TaskResourceService,\n                          protected _log: LoggerService,\n                          protected _snackbar: SnackBarService,\n                          protected _translate: TranslateService,\n                          protected _eventService: EventService,\n                          @Optional() @Inject(DATA_FIELD_PORTAL_DATA) dataFieldPortalData: DataFieldPortalData<FileListField>) {\n        super(dataFieldPortalData);\n        this.state = this.defaultState;\n        this.uploadedFiles = new Array<string>();\n        this.maxFilesNumber = Number.POSITIVE_INFINITY;\n        this.taskId = dataFieldPortalData.additionalFieldProperties.taskId as string;\n    }\n\n    ngOnInit(): void {\n        this.valueChange$ = this.dataField.valueChanges().subscribe(() => {\n            this.parseResponse();\n        });\n        if (this.dataField.validations && this.dataField.validations.length !== 0) {\n            const val = this.dataField.validations.find(validation =>\n                validation.validationRule.includes(FileListFieldValidation.MAX_FILES)\n            );\n            if (val && val.validationRule.split(' ').length === 2 && !isNaN(parseInt(val.validationRule.split(' ')[1], 10))) {\n                this.maxFilesNumber = parseInt(val.validationRule.split(' ')[1], 10);\n                this.maxFilesMessage = val.validationMessage && val.validationMessage !== '' ? val.validationMessage : null;\n            }\n        }\n    }\n\n    /**\n     * Set file picker and image elements to [FileFieldService]{@link FileFieldService}.\n     *\n     * Initialize file image.\n     */\n    ngAfterViewInit(): void {\n        if (this.fileUploadEl) {\n            this.fileUploadEl.nativeElement.onchange = () => {\n                this.upload();\n            };\n        }\n    }\n\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this.valueChange$.unsubscribe();\n    }\n\n    public chooseFile() {\n        if (this.state.uploading || this.formControlRef.disabled) {\n            return;\n        }\n        this.fileUploadEl.nativeElement.click();\n    }\n\n    /**\n     * Call after click on file field.\n     *\n     * If file field has no file uploaded\n     * [FilesUploadComponent]{@link AbstractFilesUploadComponent} via [SideMenu]{@link SideMenuService} opens.\n     *\n     * Otherwise opens a file picker from which the user can select files.\n     */\n    public upload() {\n        if (!this.fileUploadEl.nativeElement.files || this.fileUploadEl.nativeElement.files.length === 0) {\n            return;\n        }\n        if (!this.taskId) {\n            this._log.error('File cannot be uploaded. No task is set to the field.');\n            return;\n        }\n        if (this.fileUploadEl.nativeElement.files.length + this.uploadedFiles.length > this.maxFilesNumber) {\n            this._snackbar.openErrorSnackBar(this.maxFilesMessage ? this.maxFilesMessage :\n                this._translate.instant('dataField.snackBar.maxFilesExceeded') + this.maxFilesNumber\n            );\n            this.fileUploadEl.nativeElement.value = '';\n            return;\n        }\n\n        let filesToUpload = Array.from(this.fileUploadEl.nativeElement.files);\n        let sum = 0;\n        filesToUpload.forEach(item => sum += item.size);\n        if (this.dataField.maxUploadSizeInBytes &&\n            this.dataField.maxUploadSizeInBytes < sum) {\n            this._log.error('Files cannot be uploaded. Maximum size of files exceeded.');\n            this._snackbar.openErrorSnackBar(\n                this._translate.instant('dataField.snackBar.maxFilesSizeExceeded') + this.dataField.maxUploadSizeInBytes\n            );\n            this.fileUploadEl.nativeElement.value = '';\n            return;\n        }\n\n        if (this.dataField.value && this.dataField.value.namesPaths && this.dataField.value.namesPaths.length !== 0) {\n            this.dataField.value.namesPaths.forEach(namePath => {\n                filesToUpload = filesToUpload.filter(fileToUpload => fileToUpload.name !== namePath.name);\n            });\n            if (filesToUpload.length === 0) {\n                this._log.error('User chose the same files that are already uploaded. Uploading skipped');\n                this._snackbar.openErrorSnackBar(this._translate.instant('dataField.snackBar.wontUploadSameFiles'));\n                this.fileUploadEl.nativeElement.value = '';\n                return;\n            }\n        }\n\n        this.state = this.defaultState;\n        this.state.uploading = true;\n        const fileFormData = new FormData();\n\n        filesToUpload.forEach(fileToUpload => {\n            fileFormData.append('files', fileToUpload);\n        });\n        const data: FileFieldIdBody = {};\n        data[this.resolveParentTaskId()] = this.dataField.stringId;\n        fileFormData.append('data', new Blob([JSON.stringify(data)], {type: 'application/json'}));\n        this._taskResourceService.uploadFile(this.taskId,\n            this.dataField.stringId, fileFormData, true)\n            .subscribe((response: EventOutcomeMessageResource) => {\n                if ((response as ProviderProgress).type && (response as ProviderProgress).type === ProgressType.UPLOAD) {\n                    this.state.progress = (response as ProviderProgress).progress;\n                } else {\n                    this.state.completed = true;\n                    this.state.uploading = false;\n                    this.state.progress = 0;\n                    this._log.debug(\n                        `Files [${this.dataField.stringId}] were successfully uploaded`\n                    );\n                    if (response.error) {\n                        this.state.error = true;\n                        this._log.error(\n                            `File [${this.dataField.stringId}] ${this.fileUploadEl.nativeElement.files.item(0)} uploading has failed!`, response.error\n                        );\n                        if (response.error) {\n                            this._snackbar.openErrorSnackBar(this._translate.instant(response.error));\n                        } else {\n                            this._snackbar.openErrorSnackBar(this._translate.instant('dataField.snackBar.fileUploadFailed'));\n                        }\n                    } else {\n                        const changedFieldsMap: ChangedFieldsMap = this._eventService.parseChangedFieldsFromOutcomeTree(response.outcome);\n                        this.dataField.emitChangedFields(changedFieldsMap);\n                        this.state.error = false;\n                        filesToUpload.forEach(fileToUpload => {\n                            this.uploadedFiles.push(fileToUpload.name);\n                            this.dataField.value.namesPaths.push({name: fileToUpload.name});\n                            this.formControlRef.setValue(this.dataField.value.namesPaths.map(namePath => {\n                                return namePath['name'];\n                            }).join('/'));\n                        });\n                    }\n                    this.dataField.touch = true;\n                    this.dataField.update();\n                    this.fileUploadEl.nativeElement.value = '';\n                }\n            }, error => {\n                this.state.completed = true;\n                this.state.error = true;\n                this.state.uploading = false;\n                this.state.progress = 0;\n                if (error?.error?.message) {\n                    this._snackbar.openErrorSnackBar(this._translate.instant(error.error.message));\n                } else {\n                    this._snackbar.openErrorSnackBar(this._translate.instant('dataField.snackBar.fileUploadFailed'));\n                }\n                this._log.error(\n                    `File [${this.dataField.stringId}] ${this.fileUploadEl.nativeElement.files.item(0)} uploading has failed!`, error\n                );\n                this.dataField.touch = true;\n                this.dataField.update();\n                this.fileUploadEl.nativeElement.value = '';\n            });\n    }\n\n    public download(fileName: string) {\n        if (!this.dataField.value || !this.dataField.value.namesPaths ||\n            !this.dataField.value.namesPaths.find(namePath => namePath.name === fileName)) {\n            return;\n        }\n        if (!this.taskId) {\n            this._log.error('File cannot be downloaded. No task is set to the field.');\n            return;\n        }\n\n        this.state = this.defaultState;\n        this.state.downloading = true;\n        this._taskResourceService.downloadFile(this.resolveParentTaskId(),\n            this.dataField.stringId, fileName).subscribe(response => {\n            if ((response as ProviderProgress).type && (response as ProviderProgress).type === ProgressType.DOWNLOAD) {\n                this.state.progress = (response as ProviderProgress).progress;\n            } else {\n                this._log.debug(`File [${this.dataField.stringId}] ${fileName} was successfully downloaded`);\n                this.downloadViaAnchor(response as Blob, fileName);\n                this.state.downloading = false;\n                this.state.progress = 0;\n                this.dataField.downloaded.push(fileName);\n            }\n        }, error => {\n            this._log.error(`Downloading file [${this.dataField.stringId}] ${fileName} has failed!`, error);\n            this._snackbar.openErrorSnackBar(fileName + ' ' + this._translate.instant('dataField.snackBar.downloadFail'));\n            this.state.downloading = false;\n            this.state.progress = 0;\n        });\n    }\n\n    protected downloadViaAnchor(blob: Blob, fileName: string): void {\n        const a = document.createElement('a');\n        document.body.appendChild(a);\n        a.setAttribute('style', 'display: none');\n        blob = new Blob([blob], {type: 'application/octet-stream'});\n        const url = window.URL.createObjectURL(blob);\n        a.href = url;\n        a.download = fileName;\n        a.click();\n        window.URL.revokeObjectURL(url);\n        document.body.removeChild(a);\n    }\n\n    public deleteFile(fileName: string) {\n        if (!this.dataField.value || !this.dataField.value.namesPaths ||\n            !this.dataField.value.namesPaths.find(namePath => namePath.name === fileName)) {\n            return;\n        }\n        if (!this.taskId) {\n            this._log.error('File cannot be deleted. No task is set to the field.');\n            return;\n        }\n        let param = new HttpParams();\n        param = param.set(\"parentTaskId\", this.resolveParentTaskId());\n\n        this._taskResourceService.deleteFile(this.taskId,\n            this.dataField.stringId, fileName, param).pipe(take(1)).subscribe((response: EventOutcomeMessageResource) => {\n            if (response.success) {\n                const changedFieldsMap: ChangedFieldsMap = this._eventService.parseChangedFieldsFromOutcomeTree(response.outcome);\n                this.dataField.emitChangedFields(changedFieldsMap);\n                this.fileUploadEl.nativeElement.value = '';\n                this.uploadedFiles = this.uploadedFiles.filter(uploadedFile => uploadedFile !== fileName);\n                if (this.dataField.value.namesPaths) {\n                    this.dataField.value.namesPaths = this.dataField.value.namesPaths.filter(namePath => namePath.name !== fileName);\n                    this.formControlRef.setValue(this.dataField.value.namesPaths.map(namePath => {\n                        return namePath['name'];\n                    }).join('/'));\n                    this.dataField.update();\n                }\n                this.dataField.downloaded = this.dataField.downloaded.filter(one => one !== fileName);\n                this._log.debug(`File [${this.dataField.stringId}] ${fileName} was successfully deleted`);\n                this.formControlRef.markAsTouched();\n            } else {\n                this._log.error(`Deleting file [${this.dataField.stringId}] ${fileName} has failed!`, response.error);\n                this._snackbar.openErrorSnackBar(\n                    fileName + ' ' + this._translate.instant('dataField.snackBar.fileDeleteFailed')\n                );\n            }\n        });\n    }\n\n    protected get defaultState(): FilesState {\n        return {\n            progress: 0,\n            completed: false,\n            error: false,\n            uploading: false,\n            downloading: false\n        };\n    }\n\n    /**\n     * Construct display name.\n     */\n    public constructDisplayName(): string {\n        if (!!this.dataField && !!this.dataField.placeholder) {\n            return this.dataField.placeholder;\n        }\n        return this._translate.instant('dataField.file.noFile');\n    }\n\n    protected parseResponse(): void {\n        if (this.dataField.value) {\n            if (!!this.dataField.value.namesPaths && this.dataField.value.namesPaths.length !== 0) {\n                this.uploadedFiles = new Array<string>();\n                this.dataField.value.namesPaths.forEach(namePath => {\n                    this.uploadedFiles.push(namePath.name);\n                });\n            } else {\n                this.dataField.value.namesPaths = new Array<FileFieldValue>();\n            }\n            this.uploadedFiles = this.dataField.value.namesPaths.map(namePath => namePath.name);\n        }\n    }\n\n    private resolveParentTaskId(): string {\n        return !!this.dataField.parentTaskId ? this.dataField.parentTaskId : this.taskId;\n    }\n\n    public getCutProperty(i18nLabel): string {\n        if (this.labelWidth !== i18nLabel.offsetWidth) {\n            this.labelWidth = i18nLabel.offsetWidth;\n            const calculatedWidth = 'calc(0.5em + ' + i18nLabel.offsetWidth / 4 * 3 + 'px)';\n            this.cutProperty = `polygon(0 0, 0 100%, 100% 100%, 100% 0%, ${calculatedWidth} 0, ${calculatedWidth} 3px, 0.5em 3px, 0.5em 0)`;\n        }\n        return this.cutProperty;\n    }\n}\n"]}

package/esm2020/lib/data-fields/file-list-field/models/file-list-field.mjs

@@ -1,5 +1,6 @@
 import { Subject } from 'rxjs';
 import { DataField } from '../../models/abstract-data-field';
+import { ComponentPrefixes } from '../../models/component';
 import { distinctUntilChanged } from 'rxjs/operators';
 export var FileListFieldValidation;
 (function (FileListFieldValidation) {
@@ -30,6 +31,9 @@ export class FileListField extends DataField {
     get value() {
         return this._value.getValue();
     }
+    getTypedComponentType() {
+        return ComponentPrefixes.FILE_LIST + this.getComponentType();
+    }
     valueWithoutChange(value) {
         this.changed = false;
         this._value.next(value ?? { namesPaths: [] });
@@ -62,6 +66,7 @@ export class FileListField extends DataField {
             throw new Error('Data field can be initialized only once!'
                 + ' Disconnect the previous form control before initializing the data field again!');
         }
+        this.formControlRef = formControl;
         formControl.setValidators(this.resolveFormControlValidators());
         this._myValueSubscription = this._value.pipe(distinctUntilChanged(this.valueEquality)).subscribe(newValue => {
             this.valid = this._determineFormControlValidity(formControl);
@@ -80,4 +85,4 @@ export class FileListField extends DataField {
         this.update();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-list-field.js","sourceRoot":"","sources":["../../../../../../../projects/netgrif-components-core/src/lib/data-fields/file-list-field/models/file-list-field.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,OAAO,EAAC,MAAM,MAAM,CAAC;AAIzC,OAAO,EAAC,SAAS,EAAC,MAAM,kCAAkC,CAAC;AAM3D,OAAO,EAAC,oBAAoB,EAAC,MAAM,gBAAgB,CAAC;AAEpD,MAAM,CAAN,IAAY,uBAEX;AAFD,WAAY,uBAAuB;IAC/B,iDAAsB,CAAA;AAC1B,CAAC,EAFW,uBAAuB,KAAvB,uBAAuB,QAElC;AAED,MAAM,OAAO,aAAc,SAAQ,SAA6B;IA0B5D;;;;OAIG;IACH,YAAY,QAAgB,EAAE,KAAa,EAAE,QAAkB,EAAE,KAA0B,EAAE,WAAoB,EAAE,WAAoB,EAC3H,MAAe,EAAE,WAA+B,EAAU,qBAA8B,EAChF,WAAqE,EAC7E,SAAqB,EAAE,YAAqB;QACpD,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;QAH9C,0BAAqB,GAArB,qBAAqB,CAAS;QAChF,gBAAW,GAAX,WAAW,CAA0D;QAGrF,IAAI,CAAC,eAAe,GAAG,IAAI,OAAO,EAAoB,CAAC;QACvD,IAAI,CAAC,UAAU,GAAG,IAAI,KAAK,EAAU,CAAC;IAC1C,CAAC;IA/BD,IAAI,KAAK,CAAC,KAAyB;QAC/B,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACvE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;YAC/B,IAAI,CAAC,gBAAgB,CAAC,KAAK,IAAI,EAAC,UAAU,EAAE,EAAE,EAAC,CAAC,CAAC;SACpD;QACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,IAAI,EAAC,UAAU,EAAE,EAAE,EAAC,CAAC,CAAC;QAC5C,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IAC3B,CAAC;IAED,IAAI,KAAK;QACL,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;IAClC,CAAC;IAEM,kBAAkB,CAAC,KAAyB;QAC/C,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,IAAI,EAAC,UAAU,EAAE,EAAE,EAAC,CAAC,CAAC;IAChD,CAAC;IAgBD,IAAI,oBAAoB;QACpB,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACtC,CAAC;IAED,IAAI,UAAU;QACV,OAAO,IAAI,CAAC,WAAW,YAAY,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC;IAC9F,CAAC;IAED,IAAI,cAAc;QACd,OAAO,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,CAAC;IAC/C,CAAC;IAEM,iBAAiB,CAAC,MAAwB;QAC7C,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;IAED;;OAEG;IACO,aAAa,CAAC,CAAqB,EAAE,CAAqB;QAChE,IAAI,KAAK,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,UAAU,IAAI,CAAC,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,CAAC;YAClF,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,UAAU,IAAI,CAAC,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC;QAC/E,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,IAAI,CAAC,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,IAAI,CAAC,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;YAClG,KAAK,GAAG,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;SAC7F;QACD,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC;IAC/C,CAAC;IAEM,mBAAmB,CAAC,WAAwB;QAC/C,IAAI,IAAI,CAAC,WAAW,EAAE;YAClB,MAAM,IAAI,KAAK,CAAC,0CAA0C;kBACpD,iFAAiF,CAAC,CAAC;SAC5F;QAED,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,4BAA4B,EAAE,CAAC,CAAC;QAE/D,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CACxC,oBAAoB,CAAC,IAAI,CAAC,aAAa,CAAC,CAC3C,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE;YACnB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,6BAA6B,CAAC,WAAW,CAAC,CAAC;YAC7D,WAAW,CAAC,QAAQ,CAAC,CAAC,QAAQ,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE;gBAC7F,OAAO,QAAQ,CAAC,IAAI,CAAC;YACzB,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;YACd,IAAI,CAAC,MAAM,EAAE,CAAC;QAClB,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,sBAAsB,CAAC,WAAW,CAAC,CAAC;QACzC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IACpC,CAAC;IAES,sBAAsB,CAAC,WAAwB;QACrD,IAAI,CAAC,wBAAwB,CAAC,WAAW,CAAC,CAAC;QAC3C,IAAI,CAAC,MAAM,EAAE,CAAC;IAClB,CAAC;CACJ","sourcesContent":["import {Observable, Subject} from 'rxjs';\nimport {Behavior} from '../../models/behavior';\nimport {Layout} from '../../models/layout';\nimport {FileUploadMIMEType} from '../../file-field/models/file-field';\nimport {DataField} from '../../models/abstract-data-field';\nimport {FileListFieldValue} from './file-list-field-value';\nimport {Validation} from '../../models/validation';\nimport {Component} from '../../models/component';\nimport {FormControl} from '@angular/forms';\nimport {ChangedFieldsMap} from '../../../event/services/interfaces/changed-fields-map';\nimport {distinctUntilChanged} from 'rxjs/operators';\n\nexport enum FileListFieldValidation {\n    MAX_FILES = 'maxFiles'\n}\n\nexport class FileListField extends DataField<FileListFieldValue> {\n    /**\n     * Used to forward the result of the upload file backend call to the task content\n     */\n    private _changedFields$: Subject<ChangedFieldsMap>;\n    public downloaded: Array<string>;\n\n    set value(value: FileListFieldValue) {\n        if (!this.valueEquality(this._value.getValue(), value) && !this.reverting) {\n            this.changed = true;\n            this.waitingForResponse = true;\n            this.resolvePrevValue(value ?? {namesPaths: []});\n        }\n        this._value.next(value ?? {namesPaths: []});\n        this.reverting = false;\n    }\n\n    get value(): FileListFieldValue {\n        return this._value.getValue();\n    }\n\n    public valueWithoutChange(value: FileListFieldValue) {\n        this.changed = false;\n        this._value.next(value ?? {namesPaths: []});\n    }\n\n    /**\n     * Create new instance for file field with all his properties.\n     *\n     * Placeholder is a substitute for the value name if not set value.\n     */\n    constructor(stringId: string, title: string, behavior: Behavior, value?: FileListFieldValue, placeholder?: string, description?: string,\n                layout?: Layout, validations?: Array<Validation>, private _maxUploadSizeInBytes?: number,\n                private _allowTypes?: string | FileUploadMIMEType | Array<FileUploadMIMEType>,\n                component?: Component, parentTaskId?: string) {\n        super(stringId, title, value, behavior, placeholder, description, layout, validations, component, parentTaskId);\n        this._changedFields$ = new Subject<ChangedFieldsMap>();\n        this.downloaded = new Array<string>();\n    }\n\n    get maxUploadSizeInBytes(): number {\n        return this._maxUploadSizeInBytes;\n    }\n\n    get allowTypes(): string {\n        return this._allowTypes instanceof Array ? this._allowTypes.toString() : this._allowTypes;\n    }\n\n    get changedFields$(): Observable<ChangedFieldsMap> {\n        return this._changedFields$.asObservable();\n    }\n\n    public emitChangedFields(change: ChangedFieldsMap): void {\n        this._changedFields$.next(change);\n    }\n\n    /**\n     * We assume that files are always given in the same order.\n     */\n    protected valueEquality(a: FileListFieldValue, b: FileListFieldValue): boolean {\n        let array = (JSON.stringify(a) === '{}' || !a.namesPaths || a.namesPaths.length === 0) &&\n            (JSON.stringify(b) === '{}' || !b.namesPaths || b.namesPaths.length === 0);\n        if (a && a.namesPaths && a.namesPaths.length !== 0 && b && b.namesPaths && b.namesPaths.length !== 0) {\n            array = a.namesPaths.every((element, index) => element.name === b.namesPaths[index].name);\n        }\n        return (!a && !b) || (!!a && !!b && array);\n    }\n\n    public registerFormControl(formControl: FormControl): void {\n        if (this.initialized) {\n            throw new Error('Data field can be initialized only once!'\n                + ' Disconnect the previous form control before initializing the data field again!');\n        }\n\n        formControl.setValidators(this.resolveFormControlValidators());\n\n        this._myValueSubscription = this._value.pipe(\n            distinctUntilChanged(this.valueEquality)\n        ).subscribe(newValue => {\n            this.valid = this._determineFormControlValidity(formControl);\n            formControl.setValue(!newValue || !newValue.namesPaths ? '' : newValue.namesPaths.map(namePath => {\n                return namePath.name;\n            }).join('/'));\n            this.update();\n        });\n\n        this.updateFormControlState(formControl);\n        this._initialized$.next(true);\n        this.changed = false;\n        this.waitingForResponse = false;\n    }\n\n    protected updateFormControlState(formControl: FormControl): void {\n        this.subscribeToInnerSubjects(formControl);\n        this.update();\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-list-field.js","sourceRoot":"","sources":["../../../../../../../projects/netgrif-components-core/src/lib/data-fields/file-list-field/models/file-list-field.ts"],"names":[],"mappings":"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","sourcesContent":["import {Observable, Subject} from 'rxjs';\nimport {Behavior} from '../../models/behavior';\nimport {Layout} from '../../models/layout';\nimport {FileUploadMIMEType} from '../../file-field/models/file-field';\nimport {DataField} from '../../models/abstract-data-field';\nimport {FileListFieldValue} from './file-list-field-value';\nimport {Validation} from '../../models/validation';\nimport {Component, ComponentPrefixes} from '../../models/component';\nimport {FormControl} from '@angular/forms';\nimport {ChangedFieldsMap} from '../../../event/services/interfaces/changed-fields-map';\nimport {distinctUntilChanged} from 'rxjs/operators';\n\nexport enum FileListFieldValidation {\n    MAX_FILES = 'maxFiles'\n}\n\nexport class FileListField extends DataField<FileListFieldValue> {\n    /**\n     * Used to forward the result of the upload file backend call to the task content\n     */\n    private _changedFields$: Subject<ChangedFieldsMap>;\n    public downloaded: Array<string>;\n\n    set value(value: FileListFieldValue) {\n        if (!this.valueEquality(this._value.getValue(), value) && !this.reverting) {\n            this.changed = true;\n            this.waitingForResponse = true;\n            this.resolvePrevValue(value ?? {namesPaths: []});\n        }\n        this._value.next(value ?? {namesPaths: []});\n        this.reverting = false;\n    }\n\n    get value(): FileListFieldValue {\n        return this._value.getValue();\n    }\n\n    public getTypedComponentType(): string {\n        return ComponentPrefixes.FILE_LIST + this.getComponentType();\n    }\n\n    public valueWithoutChange(value: FileListFieldValue) {\n        this.changed = false;\n        this._value.next(value ?? {namesPaths: []});\n    }\n\n    /**\n     * Create new instance for file field with all his properties.\n     *\n     * Placeholder is a substitute for the value name if not set value.\n     */\n    constructor(stringId: string, title: string, behavior: Behavior, value?: FileListFieldValue, placeholder?: string, description?: string,\n                layout?: Layout, validations?: Array<Validation>, private _maxUploadSizeInBytes?: number,\n                private _allowTypes?: string | FileUploadMIMEType | Array<FileUploadMIMEType>,\n                component?: Component, parentTaskId?: string) {\n        super(stringId, title, value, behavior, placeholder, description, layout, validations, component, parentTaskId);\n        this._changedFields$ = new Subject<ChangedFieldsMap>();\n        this.downloaded = new Array<string>();\n    }\n\n    get maxUploadSizeInBytes(): number {\n        return this._maxUploadSizeInBytes;\n    }\n\n    get allowTypes(): string {\n        return this._allowTypes instanceof Array ? this._allowTypes.toString() : this._allowTypes;\n    }\n\n    get changedFields$(): Observable<ChangedFieldsMap> {\n        return this._changedFields$.asObservable();\n    }\n\n    public emitChangedFields(change: ChangedFieldsMap): void {\n        this._changedFields$.next(change);\n    }\n\n    /**\n     * We assume that files are always given in the same order.\n     */\n    protected valueEquality(a: FileListFieldValue, b: FileListFieldValue): boolean {\n        let array = (JSON.stringify(a) === '{}' || !a.namesPaths || a.namesPaths.length === 0) &&\n            (JSON.stringify(b) === '{}' || !b.namesPaths || b.namesPaths.length === 0);\n        if (a && a.namesPaths && a.namesPaths.length !== 0 && b && b.namesPaths && b.namesPaths.length !== 0) {\n            array = a.namesPaths.every((element, index) => element.name === b.namesPaths[index].name);\n        }\n        return (!a && !b) || (!!a && !!b && array);\n    }\n\n    public registerFormControl(formControl: FormControl): void {\n        if (this.initialized) {\n            throw new Error('Data field can be initialized only once!'\n                + ' Disconnect the previous form control before initializing the data field again!');\n        }\n\n        this.formControlRef = formControl;\n        formControl.setValidators(this.resolveFormControlValidators());\n\n        this._myValueSubscription = this._value.pipe(\n            distinctUntilChanged(this.valueEquality)\n        ).subscribe(newValue => {\n            this.valid = this._determineFormControlValidity(formControl);\n            formControl.setValue(!newValue || !newValue.namesPaths ? '' : newValue.namesPaths.map(namePath => {\n                return namePath.name;\n            }).join('/'));\n            this.update();\n        });\n\n        this.updateFormControlState(formControl);\n        this._initialized$.next(true);\n        this.changed = false;\n        this.waitingForResponse = false;\n    }\n\n    protected updateFormControlState(formControl: FormControl): void {\n        this.subscribeToInnerSubjects(formControl);\n        this.update();\n    }\n}\n"]}

package/esm2020/lib/data-fields/filter-field/abstract-filter-field-tab-view-content.component.mjs

@@ -8,7 +8,7 @@ import { Dashboard } from '../text-field/dashboard-portal-text-field/dashboard-v
 import { NAE_FILTER_FIELD } from './models/filter-field-injection-token';
 import { AbstractFilterFieldContentComponent } from './abstract-filter-field-content.component';
 import * as i0 from "@angular/core";
-import * as i1 from "../text-field/dashboard-portal-text-field/dashboard-portal-component-registry.service";
+import * as i1 from "../../registry/component-registry.service";
 import * as i2 from "../../search/search-service/search.service";
 import * as i3 from "./models/filter-field";
 export class AbstractFilterFieldTabViewContentComponent extends AbstractFilterFieldContentComponent {
@@ -45,7 +45,7 @@ export class AbstractFilterFieldTabViewContentComponent extends AbstractFilterFi
         this.componentPortal = this.registry.get(Dashboard.FILTER_TAB_VIEW_ID, portalInjector);
     }
 }
-AbstractFilterFieldTabViewContentComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AbstractFilterFieldTabViewContentComponent, deps: [{ token: i1.DashboardPortalComponentRegistryService }, { token: i0.Injector }, { token: NAE_FILTER_FIELD }, { token: i2.SearchService }], target: i0.ɵɵFactoryTarget.Component });
+AbstractFilterFieldTabViewContentComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AbstractFilterFieldTabViewContentComponent, deps: [{ token: i1.ComponentRegistryService }, { token: i0.Injector }, { token: NAE_FILTER_FIELD }, { token: i2.SearchService }], target: i0.ɵɵFactoryTarget.Component });
 AbstractFilterFieldTabViewContentComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: AbstractFilterFieldTabViewContentComponent, selector: "ncc-abstract-filter-field-tab-view-content", usesInheritance: true, ngImport: i0, template: '', isInline: true });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AbstractFilterFieldTabViewContentComponent, decorators: [{
             type: Component,
@@ -53,8 +53,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImpo
                     selector: 'ncc-abstract-filter-field-tab-view-content',
                     template: ''
                 }]
-        }], ctorParameters: function () { return [{ type: i1.DashboardPortalComponentRegistryService }, { type: i0.Injector }, { type: i3.FilterField, decorators: [{
+        }], ctorParameters: function () { return [{ type: i1.ComponentRegistryService }, { type: i0.Injector }, { type: i3.FilterField, decorators: [{
                     type: Inject,
                     args: [NAE_FILTER_FIELD]
                 }] }, { type: i2.SearchService }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/data-fields/filter-field/abstract-filter-field-tab-view.component.mjs

@@ -1,7 +1,7 @@
 import { Component } from '@angular/core';
 import { Dashboard } from '../text-field/dashboard-portal-text-field/dashboard-view-constants';
 import * as i0 from "@angular/core";
-import * as i1 from "../text-field/dashboard-portal-text-field/dashboard-portal-component-registry.service";
+import * as i1 from "../../registry/component-registry.service";
 import * as i2 from "./models/filter-field";
 export class AbstractFilterFieldTabViewComponent {
     constructor(_registry, _filterField, _tabContentComponent, _tabViewComponent) {
@@ -41,7 +41,7 @@ export class AbstractFilterFieldTabViewComponent {
     }
     ;
 }
-AbstractFilterFieldTabViewComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AbstractFilterFieldTabViewComponent, deps: [{ token: i1.DashboardPortalComponentRegistryService }, { token: i2.FilterField }, { token: i0.Type }, { token: i0.Type }], target: i0.ɵɵFactoryTarget.Component });
+AbstractFilterFieldTabViewComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AbstractFilterFieldTabViewComponent, deps: [{ token: i1.ComponentRegistryService }, { token: i2.FilterField }, { token: i0.Type }, { token: i0.Type }], target: i0.ɵɵFactoryTarget.Component });
 AbstractFilterFieldTabViewComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: AbstractFilterFieldTabViewComponent, selector: "ncc-abstract-filter-field-tab-view", ngImport: i0, template: '', isInline: true });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AbstractFilterFieldTabViewComponent, decorators: [{
             type: Component,
@@ -49,5 +49,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImpo
                     selector: 'ncc-abstract-filter-field-tab-view',
                     template: ''
                 }]
-        }], ctorParameters: function () { return [{ type: i1.DashboardPortalComponentRegistryService }, { type: i2.FilterField }, { type: i0.Type }, { type: i0.Type }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+        }], ctorParameters: function () { return [{ type: i1.ComponentRegistryService }, { type: i2.FilterField }, { type: i0.Type }, { type: i0.Type }]; } });
+//# sourceMappingURL=data:application/json;base64,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