@quadrel-enterprise-ui/framework 1.0.0 → 18.19.2

package/esm2022/lib/file-collector/dialog/file-collector-dialog.component.mjs

@@ -0,0 +1,47 @@
+import { Component, SkipSelf } from '@angular/core';
+import { DialogRef } from '@angular/cdk/dialog';
+import { QdFileCollectorService } from '../services/file-collector.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/file-collector.service";
+import * as i2 from "@angular/cdk/dialog";
+import * as i3 from "@angular/common";
+import * as i4 from "../../button/button/button.component";
+import * as i5 from "../../dialog/action/dialog-action.component";
+import * as i6 from "../../dialog/dialog.component";
+import * as i7 from "./item/file-collector-dialog-item.component";
+import * as i8 from "@ngx-translate/core";
+export class QdFileCollectorDialogComponent {
+    fileCollectorService;
+    dialogFileCollectorService;
+    dialogRef;
+    get fileUploads() {
+        return this.dialogFileCollectorService.fileUploads;
+    }
+    constructor(fileCollectorService, dialogFileCollectorService, dialogRef) {
+        this.fileCollectorService = fileCollectorService;
+        this.dialogFileCollectorService = dialogFileCollectorService;
+        this.dialogRef = dialogRef;
+        this.dialogFileCollectorService.config = this.fileCollectorService.config;
+    }
+    uploadFiles(files) {
+        Array.from(files).forEach((file) => this.dialogFileCollectorService.uploadFile(file));
+    }
+    close() {
+        this.dialogRef.close(this.fileUploads);
+    }
+    isCloseButtonDisabled() {
+        return !this.fileUploads.every(this._isFileUploadCompleted);
+    }
+    _isFileUploadCompleted(fileUpload) {
+        return !!fileUpload.error || fileUpload.progress === 100;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFileCollectorDialogComponent, deps: [{ token: i1.QdFileCollectorService, skipSelf: true }, { token: i1.QdFileCollectorService }, { token: i2.DialogRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdFileCollectorDialogComponent, selector: "qd-file-collector-dialog", providers: [QdFileCollectorService], ngImport: i0, template: "<qd-dialog>\n  <qd-file-collector-dialog-item\n    *ngFor=\"let fileUpload of this.fileUploads\"\n    [progress]=\"fileUpload.progress\"\n    [collectedFile]=\"fileUpload.collectedFile\"\n    [error]=\"fileUpload.error\"\n  ></qd-file-collector-dialog-item>\n  <qd-dialog-action>\n    <button qdButton (click)=\"close()\" [disabled]=\"isCloseButtonDisabled()\">\n      {{ \"i18n.qd.fileCollector.button.finish\" | translate }}\n    </button>\n  </qd-dialog-action>\n</qd-dialog>\n", dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: i4.QdButtonComponent, selector: "button[qdButton], a[qdButton], button[qd-button]", inputs: ["disabled", "color", "icon", "data-test-id", "additionalInfo"] }, { kind: "component", type: i5.QdDialogActionComponent, selector: "qd-dialog-action" }, { kind: "component", type: i6.QdDialogComponent, selector: "qd-dialog" }, { kind: "component", type: i7.QdFileCollectorDialogItemComponent, selector: "qd-file-collector-dialog-item", inputs: ["progress", "collectedFile", "error"] }, { kind: "pipe", type: i8.TranslatePipe, name: "translate" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFileCollectorDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'qd-file-collector-dialog', providers: [QdFileCollectorService], template: "<qd-dialog>\n  <qd-file-collector-dialog-item\n    *ngFor=\"let fileUpload of this.fileUploads\"\n    [progress]=\"fileUpload.progress\"\n    [collectedFile]=\"fileUpload.collectedFile\"\n    [error]=\"fileUpload.error\"\n  ></qd-file-collector-dialog-item>\n  <qd-dialog-action>\n    <button qdButton (click)=\"close()\" [disabled]=\"isCloseButtonDisabled()\">\n      {{ \"i18n.qd.fileCollector.button.finish\" | translate }}\n    </button>\n  </qd-dialog-action>\n</qd-dialog>\n" }]
+        }], ctorParameters: () => [{ type: i1.QdFileCollectorService, decorators: [{
+                    type: SkipSelf
+                }] }, { type: i1.QdFileCollectorService }, { type: i2.DialogRef }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/file-collector/dialog/item/error/file-collector-dialog-item-error.component.mjs

@@ -0,0 +1,39 @@
+// @ts-strict-ignore
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { QdUploadErrorType } from '../../../models/file-upload';
+import { QdFileCollectorService } from '../../../services/file-collector.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/file-collector.service";
+import * as i2 from "@angular/common";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "../../../../core/pipes/placeholder.pipe";
+import * as i5 from "../../../pipes/filesize.pipe";
+export class QdFileCollectorDialogItemErrorComponent {
+    fileCollectorService;
+    error;
+    QdUploadErrorType = QdUploadErrorType;
+    get maxFileSizeInBytes() {
+        return this.config?.maxFileSizeInBytes;
+    }
+    get invalidMimeTypeErrorMessageI18n() {
+        return this.config?.invalidMimeTypeErrorMessageI18n;
+    }
+    get invalidFileNameErrorMessageI18n() {
+        return this.config?.invalidFileNameErrorMessageI18n;
+    }
+    get config() {
+        return this.fileCollectorService.config;
+    }
+    constructor(fileCollectorService) {
+        this.fileCollectorService = fileCollectorService;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFileCollectorDialogItemErrorComponent, deps: [{ token: i1.QdFileCollectorService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdFileCollectorDialogItemErrorComponent, selector: "qd-file-collector-dialog-item-error", inputs: { error: "error" }, ngImport: i0, template: "<span *ngIf=\"error.message; else errorMessageNotGiven\">{{ error.message }}</span>\n<ng-template #errorMessageNotGiven [ngSwitch]=\"error.type\">\n  <span *ngSwitchCase=\"QdUploadErrorType.INVALID_MIME_TYPE\">{{\n    invalidMimeTypeErrorMessageI18n || \"i18n.qd.fileCollector.invalid.fileType\" | translate\n  }}</span>\n  <span *ngSwitchCase=\"QdUploadErrorType.INVALID_FILE_SIZE\">{{\n    \"i18n.qd.fileCollector.invalid.fileSize\"\n      | translate\n      | placeholder: \"maxFileSize\" : (maxFileSizeInBytes | filesize | async)\n  }}</span>\n  <span *ngSwitchCase=\"QdUploadErrorType.INVALID_FILE_NAME\">{{\n    invalidFileNameErrorMessageI18n || \"i18n.qd.fileCollector.invalid.fileName\" | translate\n  }}</span>\n  <span *ngSwitchCase=\"QdUploadErrorType.UNKNOWN_ERROR\">{{ \"i18n.qd.fileCollector.invalid.unknown\" | translate }}</span>\n</ng-template>\n", styles: [":host{display:flex;width:100%;align-items:center}:host span{color:#c70023}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { kind: "directive", type: i2.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i3.TranslatePipe, name: "translate" }, { kind: "pipe", type: i4.QdPlaceholderPipe, name: "placeholder" }, { kind: "pipe", type: i5.QdFileSizePipe, name: "filesize" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFileCollectorDialogItemErrorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'qd-file-collector-dialog-item-error', changeDetection: ChangeDetectionStrategy.OnPush, template: "<span *ngIf=\"error.message; else errorMessageNotGiven\">{{ error.message }}</span>\n<ng-template #errorMessageNotGiven [ngSwitch]=\"error.type\">\n  <span *ngSwitchCase=\"QdUploadErrorType.INVALID_MIME_TYPE\">{{\n    invalidMimeTypeErrorMessageI18n || \"i18n.qd.fileCollector.invalid.fileType\" | translate\n  }}</span>\n  <span *ngSwitchCase=\"QdUploadErrorType.INVALID_FILE_SIZE\">{{\n    \"i18n.qd.fileCollector.invalid.fileSize\"\n      | translate\n      | placeholder: \"maxFileSize\" : (maxFileSizeInBytes | filesize | async)\n  }}</span>\n  <span *ngSwitchCase=\"QdUploadErrorType.INVALID_FILE_NAME\">{{\n    invalidFileNameErrorMessageI18n || \"i18n.qd.fileCollector.invalid.fileName\" | translate\n  }}</span>\n  <span *ngSwitchCase=\"QdUploadErrorType.UNKNOWN_ERROR\">{{ \"i18n.qd.fileCollector.invalid.unknown\" | translate }}</span>\n</ng-template>\n", styles: [":host{display:flex;width:100%;align-items:center}:host span{color:#c70023}\n"] }]
+        }], ctorParameters: () => [{ type: i1.QdFileCollectorService }], propDecorators: { error: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/file-collector/dialog/item/file-collector-dialog-item.component.mjs

@@ -0,0 +1,41 @@
+// @ts-strict-ignore
+import { ChangeDetectionStrategy, Component, HostBinding, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../../icon/icon/icon.component";
+import * as i3 from "./progress/file-collector-dialog-item-progress.component";
+import * as i4 from "./error/file-collector-dialog-item-error.component";
+import * as i5 from "../../pipes/filesize.pipe";
+export class QdFileCollectorDialogItemComponent {
+    progress;
+    collectedFile;
+    error;
+    get isSuccessful() {
+        return !this.error && this.progress === 100;
+    }
+    get hasError() {
+        return !!this.error;
+    }
+    canUpload() {
+        return false; // TODO discuss whether we want this feature; return !!this.error;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFileCollectorDialogItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdFileCollectorDialogItemComponent, selector: "qd-file-collector-dialog-item", inputs: { progress: "progress", collectedFile: "collectedFile", error: "error" }, host: { properties: { "class.success": "this.isSuccessful", "class.error": "this.hasError" } }, ngImport: i0, template: "<span class=\"name\">{{ this.collectedFile.name }}</span>\n<qd-file-collector-dialog-item-progress\n  [progress]=\"this.progress\"\n  [error]=\"this.error\"\n></qd-file-collector-dialog-item-progress>\n<span class=\"filesize\">{{ this.collectedFile.size | filesize | async }}</span>\n<qd-icon class=\"upload\" icon=\"dataUpload\" *ngIf=\"canUpload()\"></qd-icon>\n<qd-file-collector-dialog-item-error [error]=\"this.error\" *ngIf=\"!!this.error\"></qd-file-collector-dialog-item-error>\n", styles: [":host{color:#333;font-size:.875rem;font-weight:400;line-height:1.3125rem;position:relative;display:grid;align-items:self-start;padding:.625rem 1rem .625rem 2.875rem;border-left:transparent .1875rem solid;margin-bottom:.75rem;background:#fff;gap:.25rem 1rem;grid-template-columns:30rem auto max-content;outline:rgb(151,151,151) .0625rem solid}:host qd-file-collector-dialog-item-error{grid-column:span 2}:host .filesize{text-align:right}@media (max-width: 959.98px){:host{grid-template-columns:18.75rem auto max-content}:host .name{overflow:auto;overflow-wrap:break-word}}@media (max-width: 599.98px){:host{grid-template-columns:auto auto auto}:host .name,:host qd-file-collector-dialog-item-progress{grid-column:span 2}:host qd-file-collector-dialog-item-progress,:host .filesize{order:-1}}:host:last-child{margin-bottom:0}:host.error{border-left-color:#c70023}:host.success{border-left-color:#00813a}:host:before{position:absolute;top:.5625rem;left:.875rem;content:\"\\e964\";font-family:Quadrel-Icon,sans-serif;font-size:1.25rem}:host .upload{color:#454545;cursor:pointer;font-size:1rem}:host .upload:hover,:host .upload:focus{color:#171717}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.QdIconComponent, selector: "qd-icon", inputs: ["icon"] }, { kind: "component", type: i3.QdFileCollectorDialogItemProgressComponent, selector: "qd-file-collector-dialog-item-progress", inputs: ["progress", "error"] }, { kind: "component", type: i4.QdFileCollectorDialogItemErrorComponent, selector: "qd-file-collector-dialog-item-error", inputs: ["error"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "pipe", type: i5.QdFileSizePipe, name: "filesize" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFileCollectorDialogItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'qd-file-collector-dialog-item', changeDetection: ChangeDetectionStrategy.OnPush, template: "<span class=\"name\">{{ this.collectedFile.name }}</span>\n<qd-file-collector-dialog-item-progress\n  [progress]=\"this.progress\"\n  [error]=\"this.error\"\n></qd-file-collector-dialog-item-progress>\n<span class=\"filesize\">{{ this.collectedFile.size | filesize | async }}</span>\n<qd-icon class=\"upload\" icon=\"dataUpload\" *ngIf=\"canUpload()\"></qd-icon>\n<qd-file-collector-dialog-item-error [error]=\"this.error\" *ngIf=\"!!this.error\"></qd-file-collector-dialog-item-error>\n", styles: [":host{color:#333;font-size:.875rem;font-weight:400;line-height:1.3125rem;position:relative;display:grid;align-items:self-start;padding:.625rem 1rem .625rem 2.875rem;border-left:transparent .1875rem solid;margin-bottom:.75rem;background:#fff;gap:.25rem 1rem;grid-template-columns:30rem auto max-content;outline:rgb(151,151,151) .0625rem solid}:host qd-file-collector-dialog-item-error{grid-column:span 2}:host .filesize{text-align:right}@media (max-width: 959.98px){:host{grid-template-columns:18.75rem auto max-content}:host .name{overflow:auto;overflow-wrap:break-word}}@media (max-width: 599.98px){:host{grid-template-columns:auto auto auto}:host .name,:host qd-file-collector-dialog-item-progress{grid-column:span 2}:host qd-file-collector-dialog-item-progress,:host .filesize{order:-1}}:host:last-child{margin-bottom:0}:host.error{border-left-color:#c70023}:host.success{border-left-color:#00813a}:host:before{position:absolute;top:.5625rem;left:.875rem;content:\"\\e964\";font-family:Quadrel-Icon,sans-serif;font-size:1.25rem}:host .upload{color:#454545;cursor:pointer;font-size:1rem}:host .upload:hover,:host .upload:focus{color:#171717}\n"] }]
+        }], propDecorators: { progress: [{
+                type: Input
+            }], collectedFile: [{
+                type: Input
+            }], error: [{
+                type: Input
+            }], isSuccessful: [{
+                type: HostBinding,
+                args: ['class.success']
+            }], hasError: [{
+                type: HostBinding,
+                args: ['class.error']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/file-collector/dialog/item/progress/file-collector-dialog-item-progress.component.mjs

@@ -0,0 +1,64 @@
+// @ts-strict-ignore
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { QdUploadProgressState } from '../../../models/upload-progress';
+import { BehaviorSubject, NEVER, Subject, switchMap, timer } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@ngx-translate/core";
+export class QdFileCollectorDialogItemProgressComponent {
+    progress = 0;
+    error;
+    _uploadStateSubject = new BehaviorSubject(QdUploadProgressState.STARTING);
+    _destroyed$ = new Subject();
+    uploadState$ = this._uploadStateSubject.asObservable();
+    changeUploadStateFinishingToSuccessDelay = 1000;
+    ngOnInit() {
+        this.updateUploadState();
+        this.changeUploadStateFinishingToSuccessAfterDelay();
+    }
+    changeUploadStateFinishingToSuccessAfterDelay() {
+        this.uploadState$
+            .pipe(switchMap(uploadState => uploadState === QdUploadProgressState.FINISHING ? timer(this.changeUploadStateFinishingToSuccessDelay) : NEVER), takeUntil(this._destroyed$))
+            .subscribe(() => {
+            this._uploadStateSubject.next(QdUploadProgressState.SUCCESS);
+        });
+    }
+    ngOnDestroy() {
+        this._destroyed$.complete();
+    }
+    ngOnChanges(changes) {
+        if ((changes['progress'] && !changes['progress'].firstChange) ||
+            (changes['error'] && !changes['error'].firstChange)) {
+            this.updateUploadState();
+        }
+    }
+    updateUploadState() {
+        this._uploadStateSubject.next(this.getUploadState());
+    }
+    getUploadState() {
+        if (this.error)
+            return QdUploadProgressState.ERROR;
+        if (this.progress === 0) {
+            return QdUploadProgressState.STARTING;
+        }
+        else if (this.progress === 100) {
+            return QdUploadProgressState.FINISHING;
+        }
+        else {
+            return QdUploadProgressState.IN_PROGRESS;
+        }
+    }
+    QdUploadState = QdUploadProgressState;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFileCollectorDialogItemProgressComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdFileCollectorDialogItemProgressComponent, selector: "qd-file-collector-dialog-item-progress", inputs: { progress: "progress", error: "error" }, host: { classAttribute: "qd-file-collector-dialog-item-progress" }, usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"uploadState$ | async as uploadState\">\n  <span\n    [class]=\"'upload-progress-bar-container'\"\n    *ngIf=\"\n      [QdUploadState.STARTING, QdUploadState.IN_PROGRESS, QdUploadState.FINISHING].includes(uploadState);\n      else completed\n    \"\n  >\n    <span\n      [ngClass]=\"{\n        'upload-progress-bar-progress': true,\n        filled: [QdUploadState.IN_PROGRESS, QdUploadState.FINISHING].includes(uploadState),\n        success: QdUploadState.FINISHING === uploadState\n      }\"\n      [class]=\"'upload-progress-bar-progress'\"\n      [ngStyle]=\"{ minWidth: progress + '%' }\"\n    >\n      {{ progress ? progress : 0 }}%\n    </span>\n  </span>\n  <ng-template #completed>\n    <span [class]=\"'upload-state-chip ' + uploadState\">\n      {{ \"i18n.qd.fileCollector.uploadState.\" + uploadState | translate }}\n    </span>\n  </ng-template>\n</ng-container>\n", styles: [":host{position:relative;display:flex;margin-top:.0625rem}:host .upload-progress-bar-container{width:12.5rem}:host .upload-progress-bar-progress,:host .upload-state-chip{color:#e97e00;font-size:.625rem;font-weight:500;line-height:1rem;display:inline-block;padding-right:.375rem;padding-left:.5rem;border:solid .0625rem rgb(233,126,0);border-radius:.5rem;background:#fff;transition:min-width 1s}:host .upload-progress-bar-progress.filled,:host .upload-state-chip.filled{border-color:#e97e00;background:#e97e00;color:#fff}:host .upload-progress-bar-progress.success,:host .upload-state-chip.success{border-color:#00813a;background:#fff;color:#00813a}:host .upload-progress-bar-progress.success.filled,:host .upload-state-chip.success.filled{border-color:#00813a;background:#00813a;color:#fff}:host .upload-progress-bar-progress.error,:host .upload-state-chip.error{border-color:#c70023;background:#fff;color:#c70023}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "pipe", type: i2.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFileCollectorDialogItemProgressComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'qd-file-collector-dialog-item-progress', host: { class: 'qd-file-collector-dialog-item-progress' }, changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"uploadState$ | async as uploadState\">\n  <span\n    [class]=\"'upload-progress-bar-container'\"\n    *ngIf=\"\n      [QdUploadState.STARTING, QdUploadState.IN_PROGRESS, QdUploadState.FINISHING].includes(uploadState);\n      else completed\n    \"\n  >\n    <span\n      [ngClass]=\"{\n        'upload-progress-bar-progress': true,\n        filled: [QdUploadState.IN_PROGRESS, QdUploadState.FINISHING].includes(uploadState),\n        success: QdUploadState.FINISHING === uploadState\n      }\"\n      [class]=\"'upload-progress-bar-progress'\"\n      [ngStyle]=\"{ minWidth: progress + '%' }\"\n    >\n      {{ progress ? progress : 0 }}%\n    </span>\n  </span>\n  <ng-template #completed>\n    <span [class]=\"'upload-state-chip ' + uploadState\">\n      {{ \"i18n.qd.fileCollector.uploadState.\" + uploadState | translate }}\n    </span>\n  </ng-template>\n</ng-container>\n", styles: [":host{position:relative;display:flex;margin-top:.0625rem}:host .upload-progress-bar-container{width:12.5rem}:host .upload-progress-bar-progress,:host .upload-state-chip{color:#e97e00;font-size:.625rem;font-weight:500;line-height:1rem;display:inline-block;padding-right:.375rem;padding-left:.5rem;border:solid .0625rem rgb(233,126,0);border-radius:.5rem;background:#fff;transition:min-width 1s}:host .upload-progress-bar-progress.filled,:host .upload-state-chip.filled{border-color:#e97e00;background:#e97e00;color:#fff}:host .upload-progress-bar-progress.success,:host .upload-state-chip.success{border-color:#00813a;background:#fff;color:#00813a}:host .upload-progress-bar-progress.success.filled,:host .upload-state-chip.success.filled{border-color:#00813a;background:#00813a;color:#fff}:host .upload-progress-bar-progress.error,:host .upload-state-chip.error{border-color:#c70023;background:#fff;color:#c70023}\n"] }]
+        }], propDecorators: { progress: [{
+                type: Input
+            }], error: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/file-collector/file-collector.component.mjs

@@ -0,0 +1,256 @@
+// @ts-strict-ignore
+import { Component, ElementRef, HostBinding, Input, Optional, ViewChild, ViewContainerRef } from '@angular/core';
+import isEqual from 'lodash/isEqual';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import { QdContainerActionService } from '../container/services/container-action.service';
+import { QdDialogSize } from '../dialog/models/dialog-config.model';
+import { QdDialogService } from '../dialog/services/dialog.service';
+import { QdSectionToolbarActionService } from '../section/services/section-toolbar-action.service';
+import { QdFileCollectorDialogComponent } from './dialog/file-collector-dialog.component';
+import { QdFileCollectorValidationService } from './services/file-collector-validation.service';
+import { QdFileCollectorService } from './services/file-collector.service';
+import { QdEventBrokerService } from '../core/services/event-broker.service';
+import { QdFileTypeService } from './services/file-type.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../container/services/container-action.service";
+import * as i2 from "../section/services/section-toolbar-action.service";
+import * as i3 from "../core/services/event-broker.service";
+import * as i4 from "./services/file-collector.service";
+import * as i5 from "./services/file-collector-validation.service";
+import * as i6 from "./services/file-type.service";
+import * as i7 from "../dialog/services/dialog.service";
+import * as i8 from "@angular/common";
+import * as i9 from "../button/button/button.component";
+import * as i10 from "../button/directives/button.directives";
+import * as i11 from "./allowed-files-description/file-collector-allowed-files-description.component";
+import * as i12 from "./item/file-collector-item.component";
+import * as i13 from "@ngx-translate/core";
+/**
+ * **QdFileCollectorComponent** is a flexible component for managing files within an application.
+ * It supports uploading, downloading, and displaying files, offering various options for customization and configuration.
+ *
+ * #### **Features**
+ *
+ * - **Upload**: Allows users to add new files with restrictions on file type and size.
+ * - **Download**: Enables downloads directly via URL or, if needed, through Angular’s `HttpClient`, for example, to support authorization.
+ * - **Customizable Error Handling**: Validates file size, type, and name pattern, with customizable error messages for user guidance.
+ * - **Read-only Mode**: Disables interactions in read-only mode, allowing only viewing or downloading of files.
+ * - **Standalone Enabled**: Detects if used within or outside a QLS section structure and, if outside, enables file uploads in standalone mode.
+ *
+ * #### **Interactions**
+ *
+ * File interactions are managed through several key functions:
+ *
+ * - **upload**: Adds a file to the files list if validation is successful.
+ * - **delete**: Opens a confirmation dialog that, if confirmed, removes the file from the list.
+ * - **readonly/viewonly**: In read-only or view-only mode, upload and delete functions are disabled, limiting user actions.
+ *
+ * #### **Standalone Mode**
+ *
+ * Following Quadrel’s design principles, QdFileCollector includes a standalone mode, allowing it to work independently.
+ * It automatically detects when used outside a QLS section structure and, in standalone mode, displays an "Add New" button to support file uploads.
+ *
+ * #### **File Restrictions**
+ *
+ * - **allowedFileTypes** and **allowedMimeTypes** should not be used together; using both will trigger an error log.
+ * - **maxFileSizeInBytes** sets a maximum file size allowed for uploads.
+ * - **allowedFileNamePattern** defines a regex pattern for file names; files that don’t match the pattern are rejected.
+ *
+ * #### **Error Handling**
+ *
+ * Upload errors can occur in the following cases:
+ * - **Invalid MIME Type**: When the file type is not in `allowedMimeTypes`.
+ * - **Invalid File Size**: When the file size exceeds `maxFileSizeInBytes`.
+ * - **Invalid File Name Pattern**: When the file name does not match `allowedFileNamePattern`.
+ *
+ * Error messages can be customized:
+ * - **invalidMimeTypeErrorMessageI18n**: Custom message for unsupported MIME types.
+ * - **invalidFileNameErrorMessageI18n**: Custom message for unsupported file names.
+ *
+ * #### **File Manager**
+ *
+ * QdFileManager is an interface that provides methods for uploading and deleting files.
+ * To use it with QdFileCollectorComponent, implement this interface in a custom service and provide it via the `QD_FILE_MANAGER_TOKEN` token.
+ * This service enables you to create custom file-handling logic.
+ *
+ * #### **Usage**
+ *
+ * ```typescript
+ * @Injectable()
+ * export class MyFileManager implements QdFileManager {
+ *   upload(file: File): Observable<QdUploadProgress> {
+ *     // custom implementation here
+ *   }
+ *
+ *   delete(collectedFile: QdCollectedFile): Observable<boolean> {
+ *     // custom implementation here
+ *   }
+ * }
+ *
+ * @Component({
+ *   selector: 'my-file-collector',
+ *   providers: [
+ *     {
+ *       provide: QD_FILE_MANAGER_TOKEN,
+ *       useClass: MyFileManager
+ *     }
+ *   ]
+ * })
+ * class MyFileCollectorComponent {
+ *   fileCollectorConfig: QdFileCollectorConfig = {
+ *     // configuration options here
+ *   };
+ * }
+ * ```
+ *
+ * ```html
+ * <qd-file-collector [config]="fileCollectorConfig"></qd-file-collector>
+ * ```
+ */
+export class QdFileCollectorComponent {
+    containerActionService;
+    sectionActionService;
+    eventBroker;
+    fileCollectorService;
+    fileCollectorValidationService;
+    fileTypeService;
+    dialogService;
+    viewContainerRef;
+    /**
+     * Configuration settings for the file collector.
+     */
+    config;
+    /**
+     * Static test ID for integration testing.
+     */
+    testId = 'file-collector';
+    fileInput;
+    get hasContainer() {
+        return !!this.containerActionService;
+    }
+    _subscriptions = new Subscription();
+    _viewonly$ = new BehaviorSubject(false);
+    get fileUploads() {
+        return this.fileCollectorService.fileUploads;
+    }
+    get canShowAddButton() {
+        return (!this.containerActionService && !this.sectionActionService && !this.config?.readonly && !this._viewonly$.value);
+    }
+    constructor(containerActionService, sectionActionService, eventBroker, fileCollectorService, fileCollectorValidationService, fileTypeService, dialogService, viewContainerRef) {
+        this.containerActionService = containerActionService;
+        this.sectionActionService = sectionActionService;
+        this.eventBroker = eventBroker;
+        this.fileCollectorService = fileCollectorService;
+        this.fileCollectorValidationService = fileCollectorValidationService;
+        this.fileTypeService = fileTypeService;
+        this.dialogService = dialogService;
+        this.viewContainerRef = viewContainerRef;
+    }
+    ngOnInit() {
+        this.initializeConfig(this.config);
+        this.fileCollectorService.initialize(this.config);
+        this.fileCollectorValidationService.initialize(this.config);
+        this.initViewMode();
+        if (this.containerActionService) {
+            this._subscriptions.add(this.containerActionService.action$.subscribe(() => this.clickFileInput()));
+        }
+        if (this.sectionActionService) {
+            this._subscriptions.add(this.sectionActionService.action$.pipe(filter(type => type === 'addNew')).subscribe(() => this.clickFileInput()));
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes['config'] && !changes['config'].firstChange) {
+            this.fileCollectorService.initialize(this.config);
+            this.fileCollectorValidationService.initialize(this.config);
+        }
+    }
+    ngOnDestroy() {
+        this._subscriptions.unsubscribe();
+    }
+    handleFiles(event) {
+        const dialogRef = this.dialogService.open(QdFileCollectorDialogComponent, {
+            dialogSize: QdDialogSize.Default,
+            hideCloseHeaderButton: true,
+            disableClose: true,
+            title: { i18n: 'i18n.qd.fileCollector.title' },
+            viewContainerRef: this.viewContainerRef
+        });
+        dialogRef.closed.subscribe((fileUploads = []) => {
+            fileUploads
+                .filter(fileUpload => !fileUpload.error && fileUpload.progress === 100)
+                .forEach(fileUpload => this.fileUploads.push({ ...fileUpload, newlyUploaded: true }));
+        });
+        const fileCollectorDialog = dialogRef.componentInstance;
+        fileCollectorDialog.uploadFiles(event.target.files);
+        event.target.value = '';
+    }
+    clickFileInput() {
+        if (this.fileInput.nativeElement.disabled) {
+            this.logError('Uploads disabled via config (readonly/viewonly). Remove the flag or the addNew button.');
+            return;
+        }
+        this.fileInput.nativeElement.click();
+    }
+    initializeConfig(config) {
+        if (!this.validateConfig(config))
+            return;
+        if (config?.allowedFileTypes) {
+            config.allowedMimeTypes = this.fileTypeService.getMimeTypes(config.allowedFileTypes);
+            config.allowedFileNamePattern = this.fileTypeService.getFileNamePattern(config.allowedFileTypes);
+        }
+    }
+    validateConfig(config) {
+        if (!config)
+            return true;
+        if (this.hasIncompatibleFileTypeSettings(config) && !this.isConfigConsistentWithAllowedFileTypes(config)) {
+            this.logError('Use either "allowedFileTypes" alone or "allowedMimeTypes" + "allowedFileNamePattern", not both.');
+            return false;
+        }
+        return true;
+    }
+    hasIncompatibleFileTypeSettings(config) {
+        return !!config.allowedFileTypes && (!!config.allowedMimeTypes || !!config.allowedFileNamePattern);
+    }
+    initViewMode() {
+        if (typeof this.config?.viewonly === 'boolean') {
+            this._viewonly$.next(this.config.viewonly);
+            return;
+        }
+        if (this.eventBroker)
+            this._subscriptions.add(this.eventBroker
+                .consume('operation_mode_changed')
+                .subscribe(({ payload }) => this._viewonly$.next(payload.isViewonly)));
+    }
+    isConfigConsistentWithAllowedFileTypes(config) {
+        return (isEqual(config.allowedMimeTypes, this.fileTypeService.getMimeTypes(config.allowedFileTypes)) &&
+            isEqual(config.allowedFileNamePattern, this.fileTypeService.getFileNamePattern(config.allowedFileTypes)));
+    }
+    logError(message) {
+        console.error(`QD-UI | QdFileCollector - ${message}`);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFileCollectorComponent, deps: [{ token: i1.QdContainerActionService, optional: true }, { token: i2.QdSectionToolbarActionService, optional: true }, { token: i3.QdEventBrokerService, optional: true }, { token: i4.QdFileCollectorService }, { token: i5.QdFileCollectorValidationService }, { token: i6.QdFileTypeService }, { token: i7.QdDialogService }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdFileCollectorComponent, selector: "qd-file-collector", inputs: { config: "config", testId: ["data-test-id", "testId"] }, host: { properties: { "class.has-container": "this.hasContainer" } }, providers: [QdFileCollectorService, QdFileCollectorValidationService], viewQueries: [{ propertyName: "fileInput", first: true, predicate: ["fileInput"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<button\n  qdButton\n  qdButtonGhost\n  icon=\"plus\"\n  *ngIf=\"canShowAddButton\"\n  (click)=\"clickFileInput()\"\n  [data-test-id]=\"testId + '-button-add-new'\"\n>\n  {{ config?.standaloneAddNewLabel?.i18n || \"i18n.qd.fileCollector.standalone.addNew\" | translate }}\n</button>\n\n<input\n  [disabled]=\"config?.readonly || config?.viewonly\"\n  type=\"file\"\n  (change)=\"handleFiles($event)\"\n  #fileInput\n  hidden\n  multiple=\"multiple\"\n/>\n\n<qd-file-collector-allowed-files-description\n  *ngIf=\"!config?.readonly && !config?.viewonly\"\n></qd-file-collector-allowed-files-description>\n\n<ng-container *ngFor=\"let fileUpload of this.fileUploads\">\n  <qd-file-collector-item\n    *ngIf=\"!fileUpload.error && fileUpload.progress === 100\"\n    [progress]=\"fileUpload.progress\"\n    [newlyUploaded]=\"fileUpload.newlyUploaded\"\n    [collectedFile]=\"fileUpload.collectedFile\"\n    [error]=\"fileUpload.error\"\n    [readonly]=\"config?.readonly\"\n    [viewonly]=\"config?.viewonly\"\n    [downloadFilesWithHttpClient]=\"config?.downloadFilesWithHttpClient\"\n  ></qd-file-collector-item>\n</ng-container>\n", styles: [":host{display:flex;flex-direction:column}:host>.qd-button{align-self:end;margin-bottom:1.5rem}\n"], dependencies: [{ kind: "directive", type: i8.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i8.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i9.QdButtonComponent, selector: "button[qdButton], a[qdButton], button[qd-button]", inputs: ["disabled", "color", "icon", "data-test-id", "additionalInfo"] }, { kind: "directive", type: i10.QdButtonGhostDirective, selector: "button[qdButtonGhost], a[qdButtonGhost]" }, { kind: "component", type: i11.QdFileCollectorAllowedFilesDescriptionComponent, selector: "qd-file-collector-allowed-files-description" }, { kind: "component", type: i12.QdFileCollectorItemComponent, selector: "qd-file-collector-item", inputs: ["progress", "newlyUploaded", "collectedFile", "error", "readonly", "viewonly", "downloadFilesWithHttpClient"] }, { kind: "pipe", type: i13.TranslatePipe, name: "translate" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFileCollectorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'qd-file-collector', providers: [QdFileCollectorService, QdFileCollectorValidationService], template: "<button\n  qdButton\n  qdButtonGhost\n  icon=\"plus\"\n  *ngIf=\"canShowAddButton\"\n  (click)=\"clickFileInput()\"\n  [data-test-id]=\"testId + '-button-add-new'\"\n>\n  {{ config?.standaloneAddNewLabel?.i18n || \"i18n.qd.fileCollector.standalone.addNew\" | translate }}\n</button>\n\n<input\n  [disabled]=\"config?.readonly || config?.viewonly\"\n  type=\"file\"\n  (change)=\"handleFiles($event)\"\n  #fileInput\n  hidden\n  multiple=\"multiple\"\n/>\n\n<qd-file-collector-allowed-files-description\n  *ngIf=\"!config?.readonly && !config?.viewonly\"\n></qd-file-collector-allowed-files-description>\n\n<ng-container *ngFor=\"let fileUpload of this.fileUploads\">\n  <qd-file-collector-item\n    *ngIf=\"!fileUpload.error && fileUpload.progress === 100\"\n    [progress]=\"fileUpload.progress\"\n    [newlyUploaded]=\"fileUpload.newlyUploaded\"\n    [collectedFile]=\"fileUpload.collectedFile\"\n    [error]=\"fileUpload.error\"\n    [readonly]=\"config?.readonly\"\n    [viewonly]=\"config?.viewonly\"\n    [downloadFilesWithHttpClient]=\"config?.downloadFilesWithHttpClient\"\n  ></qd-file-collector-item>\n</ng-container>\n", styles: [":host{display:flex;flex-direction:column}:host>.qd-button{align-self:end;margin-bottom:1.5rem}\n"] }]
+        }], ctorParameters: () => [{ type: i1.QdContainerActionService, decorators: [{
+                    type: Optional
+                }] }, { type: i2.QdSectionToolbarActionService, decorators: [{
+                    type: Optional
+                }] }, { type: i3.QdEventBrokerService, decorators: [{
+                    type: Optional
+                }] }, { type: i4.QdFileCollectorService }, { type: i5.QdFileCollectorValidationService }, { type: i6.QdFileTypeService }, { type: i7.QdDialogService }, { type: i0.ViewContainerRef }], propDecorators: { config: [{
+                type: Input
+            }], testId: [{
+                type: Input,
+                args: ['data-test-id']
+            }], fileInput: [{
+                type: ViewChild,
+                args: ['fileInput']
+            }], hasContainer: [{
+                type: HostBinding,
+                args: ['class.has-container']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-collector.component.js","sourceRoot":"","sources":["../../../../../libs/qd-ui/src/lib/file-collector/file-collector.component.ts","../../../../../libs/qd-ui/src/lib/file-collector/file-collector.component.html"],"names":[],"mappings":"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","sourcesContent":["// @ts-strict-ignore\nimport {\n  Component,\n  ElementRef,\n  HostBinding,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Optional,\n  SimpleChanges,\n  ViewChild,\n  ViewContainerRef\n} from '@angular/core';\nimport isEqual from 'lodash/isEqual';\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { filter } from 'rxjs/operators';\n\nimport { QdContainerActionService } from '../container/services/container-action.service';\nimport { QdDialogSize } from '../dialog/models/dialog-config.model';\nimport { QdDialogService } from '../dialog/services/dialog.service';\nimport { QdSectionToolbarActionService } from '../section/services/section-toolbar-action.service';\nimport { QdFileCollectorDialogComponent } from './dialog/file-collector-dialog.component';\nimport { QdFileCollectorConfig } from './models/file-collector-config';\nimport { QdFileUpload } from './models/file-upload';\nimport { QdFileCollectorValidationService } from './services/file-collector-validation.service';\nimport { QdFileCollectorService } from './services/file-collector.service';\nimport { QdEventBrokerService } from '../core/services/event-broker.service';\nimport { QdFileTypeService } from './services/file-type.service';\n\n/**\n * **QdFileCollectorComponent** is a flexible component for managing files within an application.\n * It supports uploading, downloading, and displaying files, offering various options for customization and configuration.\n *\n * #### **Features**\n *\n * - **Upload**: Allows users to add new files with restrictions on file type and size.\n * - **Download**: Enables downloads directly via URL or, if needed, through Angular’s `HttpClient`, for example, to support authorization.\n * - **Customizable Error Handling**: Validates file size, type, and name pattern, with customizable error messages for user guidance.\n * - **Read-only Mode**: Disables interactions in read-only mode, allowing only viewing or downloading of files.\n * - **Standalone Enabled**: Detects if used within or outside a QLS section structure and, if outside, enables file uploads in standalone mode.\n *\n * #### **Interactions**\n *\n * File interactions are managed through several key functions:\n *\n * - **upload**: Adds a file to the files list if validation is successful.\n * - **delete**: Opens a confirmation dialog that, if confirmed, removes the file from the list.\n * - **readonly/viewonly**: In read-only or view-only mode, upload and delete functions are disabled, limiting user actions.\n *\n * #### **Standalone Mode**\n *\n * Following Quadrel’s design principles, QdFileCollector includes a standalone mode, allowing it to work independently.\n * It automatically detects when used outside a QLS section structure and, in standalone mode, displays an \"Add New\" button to support file uploads.\n *\n * #### **File Restrictions**\n *\n * - **allowedFileTypes** and **allowedMimeTypes** should not be used together; using both will trigger an error log.\n * - **maxFileSizeInBytes** sets a maximum file size allowed for uploads.\n * - **allowedFileNamePattern** defines a regex pattern for file names; files that don’t match the pattern are rejected.\n *\n * #### **Error Handling**\n *\n * Upload errors can occur in the following cases:\n * - **Invalid MIME Type**: When the file type is not in `allowedMimeTypes`.\n * - **Invalid File Size**: When the file size exceeds `maxFileSizeInBytes`.\n * - **Invalid File Name Pattern**: When the file name does not match `allowedFileNamePattern`.\n *\n * Error messages can be customized:\n * - **invalidMimeTypeErrorMessageI18n**: Custom message for unsupported MIME types.\n * - **invalidFileNameErrorMessageI18n**: Custom message for unsupported file names.\n *\n * #### **File Manager**\n *\n * QdFileManager is an interface that provides methods for uploading and deleting files.\n * To use it with QdFileCollectorComponent, implement this interface in a custom service and provide it via the `QD_FILE_MANAGER_TOKEN` token.\n * This service enables you to create custom file-handling logic.\n *\n * #### **Usage**\n *\n * ```typescript\n * @Injectable()\n * export class MyFileManager implements QdFileManager {\n *   upload(file: File): Observable<QdUploadProgress> {\n *     // custom implementation here\n *   }\n *\n *   delete(collectedFile: QdCollectedFile): Observable<boolean> {\n *     // custom implementation here\n *   }\n * }\n *\n * @Component({\n *   selector: 'my-file-collector',\n *   providers: [\n *     {\n *       provide: QD_FILE_MANAGER_TOKEN,\n *       useClass: MyFileManager\n *     }\n *   ]\n * })\n * class MyFileCollectorComponent {\n *   fileCollectorConfig: QdFileCollectorConfig = {\n *     // configuration options here\n *   };\n * }\n * ```\n *\n * ```html\n * <qd-file-collector [config]=\"fileCollectorConfig\"></qd-file-collector>\n * ```\n */\n@Component({\n  selector: 'qd-file-collector',\n  templateUrl: './file-collector.component.html',\n  styleUrls: ['./file-collector.component.scss'],\n  providers: [QdFileCollectorService, QdFileCollectorValidationService]\n})\nexport class QdFileCollectorComponent implements OnInit, OnChanges, OnDestroy {\n  /**\n   * Configuration settings for the file collector.\n   */\n  @Input() config: QdFileCollectorConfig;\n\n  /**\n   * Static test ID for integration testing.\n   */\n  @Input('data-test-id') testId = 'file-collector';\n\n  @ViewChild('fileInput') fileInput: ElementRef;\n\n  @HostBinding('class.has-container') get hasContainer(): boolean {\n    return !!this.containerActionService;\n  }\n\n  private _subscriptions = new Subscription();\n  private readonly _viewonly$ = new BehaviorSubject<boolean>(false);\n\n  get fileUploads(): QdFileUpload[] {\n    return this.fileCollectorService.fileUploads;\n  }\n\n  get canShowAddButton(): boolean {\n    return (\n      !this.containerActionService && !this.sectionActionService && !this.config?.readonly && !this._viewonly$.value\n    );\n  }\n\n  constructor(\n    @Optional() private readonly containerActionService: QdContainerActionService,\n    @Optional() private readonly sectionActionService: QdSectionToolbarActionService,\n    @Optional() private readonly eventBroker: QdEventBrokerService,\n    private readonly fileCollectorService: QdFileCollectorService,\n    private readonly fileCollectorValidationService: QdFileCollectorValidationService,\n    private readonly fileTypeService: QdFileTypeService,\n    private readonly dialogService: QdDialogService,\n    private readonly viewContainerRef: ViewContainerRef\n  ) {}\n\n  ngOnInit(): void {\n    this.initializeConfig(this.config);\n    this.fileCollectorService.initialize(this.config);\n    this.fileCollectorValidationService.initialize(this.config);\n    this.initViewMode();\n\n    if (this.containerActionService) {\n      this._subscriptions.add(this.containerActionService.action$.subscribe(() => this.clickFileInput()));\n    }\n\n    if (this.sectionActionService) {\n      this._subscriptions.add(\n        this.sectionActionService.action$.pipe(filter(type => type === 'addNew')).subscribe(() => this.clickFileInput())\n      );\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['config'] && !changes['config'].firstChange) {\n      this.fileCollectorService.initialize(this.config);\n      this.fileCollectorValidationService.initialize(this.config);\n    }\n  }\n\n  ngOnDestroy(): void {\n    this._subscriptions.unsubscribe();\n  }\n\n  handleFiles(event): void {\n    const dialogRef = this.dialogService.open(QdFileCollectorDialogComponent, {\n      dialogSize: QdDialogSize.Default,\n      hideCloseHeaderButton: true,\n      disableClose: true,\n      title: { i18n: 'i18n.qd.fileCollector.title' },\n      viewContainerRef: this.viewContainerRef\n    });\n\n    dialogRef.closed.subscribe((fileUploads: QdFileUpload[] = []) => {\n      fileUploads\n        .filter(fileUpload => !fileUpload.error && fileUpload.progress === 100)\n        .forEach(fileUpload => this.fileUploads.push({ ...fileUpload, newlyUploaded: true }));\n    });\n\n    const fileCollectorDialog = dialogRef.componentInstance as QdFileCollectorDialogComponent;\n    fileCollectorDialog.uploadFiles(event.target.files);\n    event.target.value = '';\n  }\n\n  clickFileInput(): void {\n    if (this.fileInput.nativeElement.disabled) {\n      this.logError('Uploads disabled via config (readonly/viewonly). Remove the flag or the addNew button.');\n\n      return;\n    }\n\n    this.fileInput.nativeElement.click();\n  }\n\n  private initializeConfig(config: QdFileCollectorConfig): void {\n    if (!this.validateConfig(config)) return;\n\n    if (config?.allowedFileTypes) {\n      config.allowedMimeTypes = this.fileTypeService.getMimeTypes(config.allowedFileTypes);\n      config.allowedFileNamePattern = this.fileTypeService.getFileNamePattern(config.allowedFileTypes);\n    }\n  }\n\n  private validateConfig(config: QdFileCollectorConfig): boolean {\n    if (!config) return true;\n\n    if (this.hasIncompatibleFileTypeSettings(config) && !this.isConfigConsistentWithAllowedFileTypes(config)) {\n      this.logError('Use either \"allowedFileTypes\" alone or \"allowedMimeTypes\" + \"allowedFileNamePattern\", not both.');\n\n      return false;\n    }\n\n    return true;\n  }\n\n  private hasIncompatibleFileTypeSettings(config: QdFileCollectorConfig): boolean {\n    return !!config.allowedFileTypes && (!!config.allowedMimeTypes || !!config.allowedFileNamePattern);\n  }\n\n  private initViewMode(): void {\n    if (typeof this.config?.viewonly === 'boolean') {\n      this._viewonly$.next(this.config.viewonly);\n\n      return;\n    }\n\n    if (this.eventBroker)\n      this._subscriptions.add(\n        this.eventBroker\n          .consume<{ isViewonly: boolean }>('operation_mode_changed')\n          .subscribe(({ payload }) => this._viewonly$.next(payload.isViewonly))\n      );\n  }\n\n  private isConfigConsistentWithAllowedFileTypes(config: QdFileCollectorConfig): boolean {\n    return (\n      isEqual(config.allowedMimeTypes, this.fileTypeService.getMimeTypes(config.allowedFileTypes)) &&\n      isEqual(config.allowedFileNamePattern, this.fileTypeService.getFileNamePattern(config.allowedFileTypes))\n    );\n  }\n\n  private logError(message: string): void {\n    console.error(`QD-UI | QdFileCollector - ${message}`);\n  }\n}\n","<button\n  qdButton\n  qdButtonGhost\n  icon=\"plus\"\n  *ngIf=\"canShowAddButton\"\n  (click)=\"clickFileInput()\"\n  [data-test-id]=\"testId + '-button-add-new'\"\n>\n  {{ config?.standaloneAddNewLabel?.i18n || \"i18n.qd.fileCollector.standalone.addNew\" | translate }}\n</button>\n\n<input\n  [disabled]=\"config?.readonly || config?.viewonly\"\n  type=\"file\"\n  (change)=\"handleFiles($event)\"\n  #fileInput\n  hidden\n  multiple=\"multiple\"\n/>\n\n<qd-file-collector-allowed-files-description\n  *ngIf=\"!config?.readonly && !config?.viewonly\"\n></qd-file-collector-allowed-files-description>\n\n<ng-container *ngFor=\"let fileUpload of this.fileUploads\">\n  <qd-file-collector-item\n    *ngIf=\"!fileUpload.error && fileUpload.progress === 100\"\n    [progress]=\"fileUpload.progress\"\n    [newlyUploaded]=\"fileUpload.newlyUploaded\"\n    [collectedFile]=\"fileUpload.collectedFile\"\n    [error]=\"fileUpload.error\"\n    [readonly]=\"config?.readonly\"\n    [viewonly]=\"config?.viewonly\"\n    [downloadFilesWithHttpClient]=\"config?.downloadFilesWithHttpClient\"\n  ></qd-file-collector-item>\n</ng-container>\n"]}