@colijnit/sharedcomponents 1.0.56 → 1.0.58

package/esm2015/lib/components/files-upload/components/drag-drop-container.component.js

@@ -0,0 +1,115 @@
+import { __decorate } from "tslib";
+import { ElementRef, Input, Directive, Renderer2, Output, EventEmitter, HostBinding } from "@angular/core";
+import { InputBoolean } from "../../../decorator/input-boolean.decorator";
+import { DragDropContainer } from "../../../businessobject/drag-drop-container";
+import { CoOrientation } from "@colijnit/corecomponents_v12";
+import { ArrayUtils } from "@colijnit/sharedapi/build/utils/array-utils";
+import { DragDropService } from "../../../service/drag-drop.service";
+export class DragDropContainerComponent {
+    constructor(_elementRef, _renderer, _dragDropService) {
+        this._elementRef = _elementRef;
+        this._renderer = _renderer;
+        this._dragDropService = _dragDropService;
+        this.handleSort = false;
+        /**
+         * Class of the handle to drag operations
+         */
+        this.dragHandle = "";
+        // Emits when the order of sortableList items changed after a drag-drop action.
+        this.sortingChange = new EventEmitter();
+        this.showClass = true;
+        this._enabled = true;
+        this._initialized = false;
+        this._dragDropService.renderer = this._renderer;
+        this._container = new DragDropContainer(_elementRef.nativeElement, CoOrientation.Vertical);
+    }
+    set enabled(value) {
+        this._enabled = value;
+        this.handleEnabledChange();
+    }
+    ngAfterViewInit() {
+        this._initialized = true;
+        this._createDragDrop();
+        if (this._initialized) {
+            this._updateEnableDisableContainer();
+        }
+    }
+    /**
+     * Cleanup...
+     */
+    ngOnDestroy() {
+        this._removeDragDrop();
+        this._elementRef = undefined;
+    }
+    handleEnabledChange() {
+        if (!this._initialized) {
+            return;
+        }
+        if (this._enabled) {
+            this._dragDropService.enableContainer(this._container);
+            this._createDragDrop();
+        }
+        else {
+            this._dragDropService.disableContainer(this._container);
+            this._removeDragDrop();
+            this._initialized = false;
+        }
+    }
+    _createDragDrop() {
+        this._dragDropService.addContainer(this._container);
+        this._dragDropService.addDragHandle(this.dragHandle);
+        if (this.handleSort) { // subscribe drop event to be able to adapt the order of dropped items
+            this._handleOrderSub = this._dragDropService.drop.subscribe((event) => {
+                this._handleOrder(event.container, event.elementIndex, event.targetIndex);
+            });
+        }
+        this._initialized = true;
+    }
+    _removeDragDrop() {
+        this._dragDropService.removeContainer(this._container);
+        this._dragDropService.removeDragHandle(this.dragHandle);
+        if (this._handleOrderSub) {
+            this._handleOrderSub.unsubscribe();
+        }
+    }
+    _handleOrder(container, oldIndex, newIndex) {
+        if (container !== this._container) {
+            return;
+        }
+        if (newIndex === -1) {
+            newIndex = this.sortableList.length;
+        }
+        ArrayUtils.MoveElement(this.sortableList[oldIndex], newIndex, this.sortableList);
+        this.sortingChange.emit(this.sortableList);
+    }
+    _updateEnableDisableContainer() {
+        if (this._enabled) {
+            this._dragDropService.enableContainer(this._container);
+        }
+        else {
+            this._dragDropService.disableContainer(this._container);
+        }
+    }
+}
+DragDropContainerComponent.decorators = [
+    { type: Directive, args: [{
+                selector: "drag-drop-container"
+            },] }
+];
+DragDropContainerComponent.ctorParameters = () => [
+    { type: ElementRef },
+    { type: Renderer2 },
+    { type: DragDropService }
+];
+DragDropContainerComponent.propDecorators = {
+    sortableList: [{ type: Input }],
+    handleSort: [{ type: Input }],
+    enabled: [{ type: Input }],
+    dragHandle: [{ type: Input }],
+    sortingChange: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.co-drag-drop-container",] }]
+};
+__decorate([
+    InputBoolean()
+], DragDropContainerComponent.prototype, "handleSort", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-drop-container.component.js","sourceRoot":"","sources":["../../../../../../../projects/sharedcomponents/src/lib/components/files-upload/components/drag-drop-container.component.ts"],"names":[],"mappings":";AAAA,OAAO,EACL,UAAU,EACV,KAAK,EACL,SAAS,EAGT,SAAS,EACT,MAAM,EACN,YAAY,EACZ,WAAW,EACZ,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAC,YAAY,EAAC,MAAM,4CAA4C,CAAC;AACxE,OAAO,EAAC,iBAAiB,EAAC,MAAM,6CAA6C,CAAC;AAC9E,OAAO,EAAC,aAAa,EAAC,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAC,UAAU,EAAC,MAAM,6CAA6C,CAAC;AAEvE,OAAO,EAAC,eAAe,EAAC,MAAM,oCAAoC,CAAC;AAKnE,MAAM,OAAO,0BAA0B;IAoCnC,YAAoB,WAAuB,EAAU,SAAoB,EAAU,gBAAiC;QAAhG,gBAAW,GAAX,WAAW,CAAY;QAAU,cAAS,GAAT,SAAS,CAAW;QAAU,qBAAgB,GAAhB,gBAAgB,CAAiB;QA1B7G,eAAU,GAAY,KAAK,CAAC;QAQnC;;WAEG;QAEI,eAAU,GAAW,EAAE,CAAC;QAE/B,+EAA+E;QAExE,kBAAa,GAAwB,IAAI,YAAY,EAAS,CAAC;QAG/D,cAAS,GAAY,IAAI,CAAC;QAGzB,aAAQ,GAAY,IAAI,CAAC;QAEzB,iBAAY,GAAY,KAAK,CAAC;QAGlC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC;QAChD,IAAI,CAAC,UAAU,GAAG,IAAI,iBAAiB,CAAC,WAAW,CAAC,aAAa,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;IAC/F,CAAC;IA3BD,IACW,OAAO,CAAC,KAAc;QAC7B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC/B,CAAC;IAyBD,eAAe;QACX,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,IAAI,CAAC,YAAY,EAAE;YACnB,IAAI,CAAC,6BAA6B,EAAE,CAAC;SACxC;IACL,CAAC;IAED;;OAEG;IACH,WAAW;QACP,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC;IACjC,CAAC;IAEM,mBAAmB;QACtB,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACpB,OAAO;SACV;QACD,IAAI,IAAI,CAAC,QAAQ,EAAE;YACf,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACvD,IAAI,CAAC,eAAe,EAAE,CAAC;SAC1B;aAAM;YACH,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACxD,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;SAC7B;IACL,CAAC;IAEO,eAAe;QACnB,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACpD,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACrD,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,sEAAsE;YACzF,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,KAAkB,EAAE,EAAE;gBAC/E,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;YAC9E,CAAC,CAAC,CAAC;SACN;QACD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;IAC7B,CAAC;IAEO,eAAe;QACnB,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACvD,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACxD,IAAI,IAAI,CAAC,eAAe,EAAE;YACtB,IAAI,CAAC,eAAe,CAAC,WAAW,EAAE,CAAC;SACtC;IACL,CAAC;IAEO,YAAY,CAAC,SAA4B,EAAE,QAAgB,EAAE,QAAgB;QACjF,IAAI,SAAS,KAAK,IAAI,CAAC,UAAU,EAAE;YAC/B,OAAO;SACV;QACD,IAAI,QAAQ,KAAK,CAAC,CAAC,EAAE;YACjB,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC;SACvC;QACD,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QACjF,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAC/C,CAAC;IAEO,6BAA6B;QACjC,IAAI,IAAI,CAAC,QAAQ,EAAE;YACf,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;SAC1D;aAAM;YACH,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;SAC3D;IACL,CAAC;;;YA9GJ,SAAS,SAAC;gBACT,QAAQ,EAAE,qBAAqB;aAChC;;;YApBC,UAAU;YAKV,SAAS;YAWH,eAAe;;;2BAUlB,KAAK;yBAGL,KAAK;sBAIL,KAAK;yBASL,KAAK;4BAIL,MAAM;wBAGN,WAAW,SAAC,8BAA8B;;AAlB3C;IADC,YAAY,EAAE;8DACoB","sourcesContent":["import {\r\n  ElementRef,\r\n  Input,\r\n  Directive,\r\n  AfterViewInit,\r\n  OnDestroy,\r\n  Renderer2,\r\n  Output,\r\n  EventEmitter,\r\n  HostBinding\r\n} from \"@angular/core\";\r\nimport {Subscription} from \"rxjs\";\r\nimport {InputBoolean} from \"../../../decorator/input-boolean.decorator\";\r\nimport {DragDropContainer} from \"../../../businessobject/drag-drop-container\";\r\nimport {CoOrientation} from \"@colijnit/corecomponents_v12\";\r\nimport {ArrayUtils} from \"@colijnit/sharedapi/build/utils/array-utils\";\r\nimport {CoDropEvent} from \"../../../event/co-drop-event\";\r\nimport {DragDropService} from \"../../../service/drag-drop.service\";\r\n\r\n@Directive({\r\n  selector: \"drag-drop-container\"\r\n})\r\nexport class DragDropContainerComponent implements AfterViewInit, OnDestroy {\r\n\r\n    /**\r\n     * Model of list containing draggable items\r\n     */\r\n    @Input()\r\n    public sortableList: any[];\r\n\r\n    @Input()\r\n    @InputBoolean()\r\n    public handleSort: boolean = false;\r\n\r\n    @Input()\r\n    public set enabled(value: boolean) {\r\n        this._enabled = value;\r\n        this.handleEnabledChange();\r\n    }\r\n\r\n    /**\r\n     * Class of the handle to drag operations\r\n     */\r\n    @Input()\r\n    public dragHandle: string = \"\";\r\n\r\n    // Emits when the order of sortableList items changed after a drag-drop action.\r\n    @Output()\r\n    public sortingChange: EventEmitter<any[]> = new EventEmitter<any[]>();\r\n\r\n    @HostBinding(\"class.co-drag-drop-container\")\r\n    public showClass: boolean = true;\r\n\r\n    private _container: DragDropContainer;\r\n    private _enabled: boolean = true;\r\n    private _handleOrderSub: Subscription;\r\n    private _initialized: boolean = false;\r\n\r\n    constructor(private _elementRef: ElementRef, private _renderer: Renderer2, private _dragDropService: DragDropService) {\r\n        this._dragDropService.renderer = this._renderer;\r\n        this._container = new DragDropContainer(_elementRef.nativeElement, CoOrientation.Vertical);\r\n    }\r\n\r\n    ngAfterViewInit(): void {\r\n        this._initialized = true;\r\n        this._createDragDrop();\r\n        if (this._initialized) {\r\n            this._updateEnableDisableContainer();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Cleanup...\r\n     */\r\n    ngOnDestroy(): void {\r\n        this._removeDragDrop();\r\n        this._elementRef = undefined;\r\n    }\r\n\r\n    public handleEnabledChange(): void {\r\n        if (!this._initialized) {\r\n            return;\r\n        }\r\n        if (this._enabled) {\r\n            this._dragDropService.enableContainer(this._container);\r\n            this._createDragDrop();\r\n        } else {\r\n            this._dragDropService.disableContainer(this._container);\r\n            this._removeDragDrop();\r\n            this._initialized = false;\r\n        }\r\n    }\r\n\r\n    private _createDragDrop(): void {\r\n        this._dragDropService.addContainer(this._container);\r\n        this._dragDropService.addDragHandle(this.dragHandle);\r\n        if (this.handleSort) { // subscribe drop event to be able to adapt the order of dropped items\r\n            this._handleOrderSub = this._dragDropService.drop.subscribe((event: CoDropEvent) => {\r\n                this._handleOrder(event.container, event.elementIndex, event.targetIndex);\r\n            });\r\n        }\r\n        this._initialized = true;\r\n    }\r\n\r\n    private _removeDragDrop(): void {\r\n        this._dragDropService.removeContainer(this._container);\r\n        this._dragDropService.removeDragHandle(this.dragHandle);\r\n        if (this._handleOrderSub) {\r\n            this._handleOrderSub.unsubscribe();\r\n        }\r\n    }\r\n\r\n    private _handleOrder(container: DragDropContainer, oldIndex: number, newIndex: number): void {\r\n        if (container !== this._container) {\r\n            return;\r\n        }\r\n        if (newIndex === -1) {\r\n            newIndex = this.sortableList.length;\r\n        }\r\n        ArrayUtils.MoveElement(this.sortableList[oldIndex], newIndex, this.sortableList);\r\n        this.sortingChange.emit(this.sortableList);\r\n    }\r\n\r\n    private _updateEnableDisableContainer(): void {\r\n        if (this._enabled) {\r\n            this._dragDropService.enableContainer(this._container);\r\n        } else {\r\n            this._dragDropService.disableContainer(this._container);\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2015/lib/components/files-upload/files-upload.component.js

@@ -0,0 +1,131 @@
+import { __awaiter, __decorate } from "tslib";
+import { Component, ComponentFactoryResolver, ContentChild, EventEmitter, forwardRef, HostBinding, Input, Output, ViewChild, ViewContainerRef, ViewEncapsulation } from "@angular/core";
+import { BaseFileUploadComponent } from "./components/base-file-upload.component";
+import { SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME } from "@colijnit/corecomponents_v12";
+import { DictionaryService } from "../../service/dictionary.service";
+import { InputBoolean } from "../../decorator/input-boolean.decorator";
+// A component that lets the user make a list of files from its device. Doesn't actually upload, but outputs chosen files as filesChanged.
+export class FilesUploadComponent extends BaseFileUploadComponent {
+    constructor(
+    //promptService: PromptService,
+    dictionaryService, 
+    //userService: UserService,
+    _container, _factory) {
+        super(dictionaryService, _container, _factory);
+        this._container = _container;
+        this._factory = _factory;
+        // Input button label
+        this.label = "UPLOAD_FILE";
+        this.customImageClick = false;
+        this.isEditable = false;
+        this.hideAvatars = false;
+        this.editSlideoutSubmit = new EventEmitter();
+        this.tagsChangeEvent = new EventEmitter();
+        this.imageClick = new EventEmitter();
+        this.slideoutShown = false;
+        this.isDropzone = false;
+    }
+    set dropzone(value) {
+        this.isDropzone = value;
+    }
+    showClass() {
+        return true;
+    }
+    get editable() {
+        return this.canAdd;
+    }
+    get empty() {
+        return !this.documents || this.documents.length === 0;
+    }
+    ngOnDestroy() {
+        this.slideoutTemplate = undefined;
+        this.input = undefined;
+        super.ngOnDestroy();
+    }
+    openFileBrowser() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.input && this.input.nativeElement) {
+                this.input.nativeElement.click();
+            }
+        });
+    }
+    handleAddClick() {
+        this.openFileBrowser();
+    }
+}
+FilesUploadComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-files-upload",
+                template: `
+        <div class="files-upload-wrapper">
+            <drag-drop-container
+                                 [sortableList]="documents"
+                                 (sortingChange)="handleSortingChange($event)"
+                                 [handleSort]="true"
+                                 dragHandle="tile"
+                                 [enabled]="!noDragDropOrdering">
+                <co-file-upload *ngIf="canAdd && addWithButton" class="add-file"
+                             isAddingTile
+                             icon="plus_round_open"
+                             [link]="true"
+                             [label]="label | localize"
+                             (mouseover)="mouseOverAdd = true"
+                             (mouseout)="mouseOverAdd = false"
+                             (click)="handleAddClick()"></co-file-upload> <!-- (click)="handleAddClick()" -->
+                <co-file-upload *ngFor="let file of documents" class="tile"
+                             [readonly]="file.readonly || readonly"
+                             [class.hidden]="hideAvatars ? file.isAvatar : false"
+                             [file]="file"
+                             [label]="file.fileName"
+                             [showTrashCan]="canDelete"
+                             [fileSavesOnPopupOkClick]="fileSavesOnPopupOkClick"
+                             [isEditable]="isEditable"
+                             [customImageClick]="customImageClick"
+                             (imageClick)="imageClick.emit($event)"
+                             (deleteClick)="handleDelete(file)"
+                             (editClick)="handleEditDocumentClick($event)"></co-file-upload>
+            </drag-drop-container>
+            <span class="maxuploadsize" textContent="getMaxFileSizeNotition()" [class.show]="mouseOverAdd"></span>
+            <input #inputFile [accept]="acceptedUploadFormats" (change)="handleFileChange($event)" type="file" hidden multiple/>
+        </div>
+    `,
+                encapsulation: ViewEncapsulation.None,
+                providers: [
+                    {
+                        provide: SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME,
+                        useExisting: forwardRef(() => FilesUploadComponent)
+                    }
+                ]
+            },] }
+];
+FilesUploadComponent.ctorParameters = () => [
+    { type: DictionaryService },
+    { type: ViewContainerRef },
+    { type: ComponentFactoryResolver }
+];
+FilesUploadComponent.propDecorators = {
+    dropzone: [{ type: Input }],
+    slideoutTemplate: [{ type: ContentChild, args: ["slideoutTemplate", { static: true },] }],
+    input: [{ type: ViewChild, args: ["inputFile", { static: true },] }],
+    label: [{ type: Input }],
+    cfgNames: [{ type: Input }],
+    customImageClick: [{ type: Input }],
+    isEditable: [{ type: Input }],
+    hideAvatars: [{ type: Input }],
+    fileSavesOnPopupOkClick: [{ type: Input }],
+    selected: [{ type: Input }],
+    editSlideoutSubmit: [{ type: Output }],
+    tagsChangeEvent: [{ type: Output }],
+    imageClick: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ['class.co-files-upload',] }],
+    editable: [{ type: HostBinding, args: ["class.editable",] }],
+    empty: [{ type: HostBinding, args: ["class.empty",] }],
+    isDropzone: [{ type: HostBinding, args: ['class.dropzone',] }]
+};
+__decorate([
+    InputBoolean()
+], FilesUploadComponent.prototype, "isEditable", void 0);
+__decorate([
+    InputBoolean()
+], FilesUploadComponent.prototype, "hideAvatars", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"files-upload.component.js","sourceRoot":"","sources":["../../../../../../projects/sharedcomponents/src/lib/components/files-upload/files-upload.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  ComponentFactoryResolver,\r\n  ContentChild,\r\n  ElementRef,\r\n  EventEmitter, forwardRef,\r\n  HostBinding,\r\n  Input,\r\n  OnDestroy,\r\n  Output,\r\n  TemplateRef,\r\n  ViewChild,\r\n  ViewContainerRef,\r\n  ViewEncapsulation\r\n} from \"@angular/core\";\r\nimport {BaseFileUploadComponent} from \"./components/base-file-upload.component\";\r\nimport {SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME} from \"@colijnit/corecomponents_v12\";\r\nimport {DictionaryService} from \"../../service/dictionary.service\";\r\nimport {CoDocument} from \"@colijnit/mainapi/build/model/co-document\";\r\nimport {TagTreeItem} from \"@colijnit/mainapi/build/model/tag-tree-item.bo\";\r\nimport {InputBoolean} from \"../../decorator/input-boolean.decorator\";\r\n\r\n@Component({\r\n    selector: \"co-files-upload\",\r\n    template: `\r\n        <div class=\"files-upload-wrapper\">\r\n            <drag-drop-container\r\n                                 [sortableList]=\"documents\"\r\n                                 (sortingChange)=\"handleSortingChange($event)\"\r\n                                 [handleSort]=\"true\"\r\n                                 dragHandle=\"tile\"\r\n                                 [enabled]=\"!noDragDropOrdering\">\r\n                <co-file-upload *ngIf=\"canAdd && addWithButton\" class=\"add-file\"\r\n                             isAddingTile\r\n                             icon=\"plus_round_open\"\r\n                             [link]=\"true\"\r\n                             [label]=\"label | localize\"\r\n                             (mouseover)=\"mouseOverAdd = true\"\r\n                             (mouseout)=\"mouseOverAdd = false\"\r\n                             (click)=\"handleAddClick()\"></co-file-upload> <!-- (click)=\"handleAddClick()\" -->\r\n                <co-file-upload *ngFor=\"let file of documents\" class=\"tile\"\r\n                             [readonly]=\"file.readonly || readonly\"\r\n                             [class.hidden]=\"hideAvatars ? file.isAvatar : false\"\r\n                             [file]=\"file\"\r\n                             [label]=\"file.fileName\"\r\n                             [showTrashCan]=\"canDelete\"\r\n                             [fileSavesOnPopupOkClick]=\"fileSavesOnPopupOkClick\"\r\n                             [isEditable]=\"isEditable\"\r\n                             [customImageClick]=\"customImageClick\"\r\n                             (imageClick)=\"imageClick.emit($event)\"\r\n                             (deleteClick)=\"handleDelete(file)\"\r\n                             (editClick)=\"handleEditDocumentClick($event)\"></co-file-upload>\r\n            </drag-drop-container>\r\n            <span class=\"maxuploadsize\" textContent=\"getMaxFileSizeNotition()\" [class.show]=\"mouseOverAdd\"></span>\r\n            <input #inputFile [accept]=\"acceptedUploadFormats\" (change)=\"handleFileChange($event)\" type=\"file\" hidden multiple/>\r\n        </div>\r\n    `,\r\n    encapsulation: ViewEncapsulation.None,\r\n    providers: [\r\n        {\r\n            provide: SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME,\r\n            useExisting: forwardRef(() => FilesUploadComponent)\r\n        }\r\n    ]\r\n})\r\n// A component that lets the user make a list of files from its device. Doesn't actually upload, but outputs chosen files as filesChanged.\r\nexport class FilesUploadComponent extends BaseFileUploadComponent implements OnDestroy {\r\n\r\n    @Input()\r\n    public set dropzone(value: boolean) {\r\n        this.isDropzone = value;\r\n    }\r\n\r\n    //todo see if this is used anywhere if not, remove\r\n    @ContentChild(\"slideoutTemplate\", {static: true})\r\n    public slideoutTemplate: TemplateRef<any>;\r\n\r\n    // (Hidden) input for file upload facilities\r\n    @ViewChild(\"inputFile\", {static: true})\r\n    public input: ElementRef;\r\n\r\n    // Input button label\r\n    @Input()\r\n    public label: string = \"UPLOAD_FILE\";\r\n\r\n    @Input()\r\n    public cfgNames: any;\r\n\r\n    @Input()\r\n    public customImageClick: boolean = false;\r\n\r\n    @Input()\r\n    @InputBoolean()\r\n    public isEditable: boolean = false;\r\n\r\n    @Input() @InputBoolean()\r\n    public hideAvatars: boolean = false;\r\n\r\n    @Input()\r\n    public fileSavesOnPopupOkClick: string;\r\n\r\n    @Input()\r\n    public selected: string;\r\n\r\n    @Output()\r\n    public readonly editSlideoutSubmit: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n    @Output()\r\n    public tagsChangeEvent: EventEmitter<TagTreeItem[]> = new EventEmitter<TagTreeItem[]>();\r\n\r\n    @Output()\r\n    public imageClick: EventEmitter<CoDocument> = new EventEmitter<CoDocument>();\r\n\r\n\r\n    @HostBinding('class.co-files-upload')\r\n    public showClass() {\r\n      return true;\r\n    }\r\n\r\n    @HostBinding(\"class.editable\")\r\n    public get editable(): boolean {\r\n        return this.canAdd;\r\n    }\r\n\r\n    @HostBinding(\"class.empty\")\r\n    public get empty(): boolean {\r\n        return !this.documents || this.documents.length === 0;\r\n    }\r\n\r\n    public mouseOverAdd: boolean;\r\n    public slideoutShown: boolean = false;\r\n    @HostBinding('class.dropzone')\r\n    public isDropzone: boolean = false;\r\n\r\n    constructor(\r\n        //promptService: PromptService,\r\n        dictionaryService: DictionaryService,\r\n        //userService: UserService,\r\n        protected _container: ViewContainerRef,\r\n        protected _factory: ComponentFactoryResolver,\r\n        //protected _dataService: DataService,\r\n        //protected _baseDataDalRepository: BaseDataDalRepository,\r\n       // protected _generalDalRepository: GeneralDalRepository,\r\n        //protected _coDocumentDataLoader: CoDocumentDataLoaderService,\r\n        //private _workability: AppWorkabilityService,\r\n        //private _fileTypeImgPipe: FileTypeImagePipe\r\n    ) {\r\n        super(dictionaryService, _container, _factory);\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        this.slideoutTemplate = undefined;\r\n        this.input = undefined;\r\n        super.ngOnDestroy();\r\n    }\r\n\r\n    public async openFileBrowser(): Promise<void> {\r\n        if (this.input && this.input.nativeElement) {\r\n            this.input.nativeElement.click();\r\n        }\r\n    }\r\n\r\n    public handleAddClick(): void {\r\n        this.openFileBrowser();\r\n    }\r\n\r\n    //todo check if this can be removed at the end of the run\r\n    /*public onCustomClose(): void {\r\n        this.documentUnderEdit = undefined;\r\n    }*/\r\n}\r\n"]}

package/esm2015/lib/components/files-upload/files-upload.module.js

@@ -0,0 +1,47 @@
+import { NgModule } from "@angular/core";
+import { ButtonModule, CoDialogModule, FormModule, IconModule, InputCheckboxModule, InputTextModule, ScreenConfigurationModule } from "@colijnit/corecomponents_v12";
+import { LocalizationModule } from "../../localization/localization.module";
+import { DragDropContainerComponent } from "./components/drag-drop-container.component";
+import { ImageDisplayModule } from "../image-display/image-display.module";
+import { CommonModule } from "@angular/common";
+import { Overlay } from "@angular/cdk/overlay";
+import { FileTypeImagePipe } from "../../pipe/file-type-image.pipe";
+import { FilesUploadComponent } from "./files-upload.component";
+import { FileUploadModule } from "../file-upload/file-upload.module";
+import { FileUploadPopupModule } from "../file-upload-popup/file-upload-popup.module";
+import { AppFileDropzoneModule } from "../app-file-dropzone/app-file-dropzone.module";
+export class FilesUploadModule {
+}
+FilesUploadModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CoDialogModule,
+                    FormModule,
+                    InputTextModule,
+                    ScreenConfigurationModule,
+                    ButtonModule,
+                    LocalizationModule,
+                    IconModule,
+                    ImageDisplayModule,
+                    CommonModule,
+                    // TagsModule,
+                    InputCheckboxModule,
+                    FileUploadModule,
+                    FileUploadPopupModule,
+                    AppFileDropzoneModule
+                ],
+                declarations: [
+                    FilesUploadComponent,
+                    DragDropContainerComponent
+                ],
+                exports: [
+                    FilesUploadComponent,
+                    DragDropContainerComponent
+                ],
+                providers: [
+                    Overlay,
+                    FileTypeImagePipe
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/image-display/image-display.component.js

@@ -0,0 +1,36 @@
+import { Component, forwardRef, HostBinding, Input, ViewEncapsulation } from '@angular/core';
+import { SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME } from '@colijnit/corecomponents_v12';
+export class ImageDisplayComponent {
+    constructor() {
+        // The (localized) text to show when there is no image. Defaults to 'NO_IMAGE'.
+        this.label = "NO_IMAGE";
+    }
+    showClass() {
+        return true;
+    }
+}
+ImageDisplayComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-image-display",
+                template: `
+    <img class="image" *ngIf="!!model" [src]="model">
+    <div class="no-image" *ngIf="!model">
+      <div class="img"></div>
+      <div class="no-image-label" [textContent]="label | localize"></div>
+    </div>
+  `,
+                providers: [{
+                        provide: SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME,
+                        useExisting: forwardRef(() => ImageDisplayComponent)
+                    }
+                ],
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+ImageDisplayComponent.propDecorators = {
+    model: [{ type: Input }],
+    label: [{ type: Input }],
+    showClass: [{ type: HostBinding, args: ['class.co-image-display',] }],
+    hidden: [{ type: HostBinding, args: ["class.co-transaction-hidden",] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/image-display/image-display.module.js

@@ -0,0 +1,23 @@
+import { NgModule } from "@angular/core";
+import { ImageDisplayComponent } from "./image-display.component";
+import { CoreComponentsTranslationModule } from "@colijnit/corecomponents_v12";
+import { CommonModule } from "@angular/common";
+import { LocalizationModule } from "../../localization/localization.module";
+export class ImageDisplayModule {
+}
+ImageDisplayModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CoreComponentsTranslationModule,
+                    CommonModule,
+                    LocalizationModule
+                ],
+                declarations: [
+                    ImageDisplayComponent
+                ],
+                exports: [
+                    ImageDisplayComponent
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1hZ2UtZGlzcGxheS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zaGFyZWRjb21wb25lbnRzL3NyYy9saWIvY29tcG9uZW50cy9pbWFnZS1kaXNwbGF5L2ltYWdlLWRpc3BsYXkubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFDLHFCQUFxQixFQUFDLE1BQU0sMkJBQTJCLENBQUM7QUFDaEUsT0FBTyxFQUFDLCtCQUErQixFQUFDLE1BQU0sOEJBQThCLENBQUM7QUFDN0UsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBQzdDLE9BQU8sRUFBQyxrQkFBa0IsRUFBQyxNQUFNLHdDQUF3QyxDQUFDO0FBZTFFLE1BQU0sT0FBTyxrQkFBa0I7OztZQWI5QixRQUFRLFNBQUM7Z0JBQ04sT0FBTyxFQUFFO29CQUNMLCtCQUErQjtvQkFDL0IsWUFBWTtvQkFDWixrQkFBa0I7aUJBQ3JCO2dCQUNILFlBQVksRUFBRTtvQkFDWixxQkFBcUI7aUJBQ3RCO2dCQUNELE9BQU8sRUFBRTtvQkFDUCxxQkFBcUI7aUJBQ3RCO2FBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge05nTW9kdWxlfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5pbXBvcnQge0ltYWdlRGlzcGxheUNvbXBvbmVudH0gZnJvbSBcIi4vaW1hZ2UtZGlzcGxheS5jb21wb25lbnRcIjtcclxuaW1wb3J0IHtDb3JlQ29tcG9uZW50c1RyYW5zbGF0aW9uTW9kdWxlfSBmcm9tIFwiQGNvbGlqbml0L2NvcmVjb21wb25lbnRzX3YxMlwiO1xyXG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vblwiO1xyXG5pbXBvcnQge0xvY2FsaXphdGlvbk1vZHVsZX0gZnJvbSBcIi4uLy4uL2xvY2FsaXphdGlvbi9sb2NhbGl6YXRpb24ubW9kdWxlXCI7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gICAgaW1wb3J0czogW1xyXG4gICAgICAgIENvcmVDb21wb25lbnRzVHJhbnNsYXRpb25Nb2R1bGUsXHJcbiAgICAgICAgQ29tbW9uTW9kdWxlLFxyXG4gICAgICAgIExvY2FsaXphdGlvbk1vZHVsZVxyXG4gICAgXSxcclxuICBkZWNsYXJhdGlvbnM6IFtcclxuICAgIEltYWdlRGlzcGxheUNvbXBvbmVudFxyXG4gIF0sXHJcbiAgZXhwb3J0czogW1xyXG4gICAgSW1hZ2VEaXNwbGF5Q29tcG9uZW50XHJcbiAgXVxyXG59KVxyXG5leHBvcnQgY2xhc3MgSW1hZ2VEaXNwbGF5TW9kdWxlIHtcclxuXHJcbn1cclxuIl19