@colijnit/sharedcomponents 1.0.62 → 1.0.64

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

@@ -1,115 +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":"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","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"]}
+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":"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","sourcesContent":["import {\n  ElementRef,\n  Input,\n  Directive,\n  AfterViewInit,\n  OnDestroy,\n  Renderer2,\n  Output,\n  EventEmitter,\n  HostBinding\n} from \"@angular/core\";\nimport {Subscription} from \"rxjs\";\nimport {InputBoolean} from \"../../../decorator/input-boolean.decorator\";\nimport {DragDropContainer} from \"../../../businessobject/drag-drop-container\";\nimport {CoOrientation} from \"@colijnit/corecomponents_v12\";\nimport {ArrayUtils} from \"@colijnit/sharedapi/build/utils/array-utils\";\nimport {CoDropEvent} from \"../../../event/co-drop-event\";\nimport {DragDropService} from \"../../../service/drag-drop.service\";\n\n@Directive({\n  selector: \"drag-drop-container\"\n})\nexport class DragDropContainerComponent implements AfterViewInit, OnDestroy {\n\n    /**\n     * Model of list containing draggable items\n     */\n    @Input()\n    public sortableList: any[];\n\n    @Input()\n    @InputBoolean()\n    public handleSort: boolean = false;\n\n    @Input()\n    public set enabled(value: boolean) {\n        this._enabled = value;\n        this.handleEnabledChange();\n    }\n\n    /**\n     * Class of the handle to drag operations\n     */\n    @Input()\n    public dragHandle: string = \"\";\n\n    // Emits when the order of sortableList items changed after a drag-drop action.\n    @Output()\n    public sortingChange: EventEmitter<any[]> = new EventEmitter<any[]>();\n\n    @HostBinding(\"class.co-drag-drop-container\")\n    public showClass: boolean = true;\n\n    private _container: DragDropContainer;\n    private _enabled: boolean = true;\n    private _handleOrderSub: Subscription;\n    private _initialized: boolean = false;\n\n    constructor(private _elementRef: ElementRef, private _renderer: Renderer2, private _dragDropService: DragDropService) {\n        this._dragDropService.renderer = this._renderer;\n        this._container = new DragDropContainer(_elementRef.nativeElement, CoOrientation.Vertical);\n    }\n\n    ngAfterViewInit(): void {\n        this._initialized = true;\n        this._createDragDrop();\n        if (this._initialized) {\n            this._updateEnableDisableContainer();\n        }\n    }\n\n    /**\n     * Cleanup...\n     */\n    ngOnDestroy(): void {\n        this._removeDragDrop();\n        this._elementRef = undefined;\n    }\n\n    public handleEnabledChange(): void {\n        if (!this._initialized) {\n            return;\n        }\n        if (this._enabled) {\n            this._dragDropService.enableContainer(this._container);\n            this._createDragDrop();\n        } else {\n            this._dragDropService.disableContainer(this._container);\n            this._removeDragDrop();\n            this._initialized = false;\n        }\n    }\n\n    private _createDragDrop(): void {\n        this._dragDropService.addContainer(this._container);\n        this._dragDropService.addDragHandle(this.dragHandle);\n        if (this.handleSort) { // subscribe drop event to be able to adapt the order of dropped items\n            this._handleOrderSub = this._dragDropService.drop.subscribe((event: CoDropEvent) => {\n                this._handleOrder(event.container, event.elementIndex, event.targetIndex);\n            });\n        }\n        this._initialized = true;\n    }\n\n    private _removeDragDrop(): void {\n        this._dragDropService.removeContainer(this._container);\n        this._dragDropService.removeDragHandle(this.dragHandle);\n        if (this._handleOrderSub) {\n            this._handleOrderSub.unsubscribe();\n        }\n    }\n\n    private _handleOrder(container: DragDropContainer, oldIndex: number, newIndex: number): void {\n        if (container !== this._container) {\n            return;\n        }\n        if (newIndex === -1) {\n            newIndex = this.sortableList.length;\n        }\n        ArrayUtils.MoveElement(this.sortableList[oldIndex], newIndex, this.sortableList);\n        this.sortingChange.emit(this.sortableList);\n    }\n\n    private _updateEnableDisableContainer(): void {\n        if (this._enabled) {\n            this._dragDropService.enableContainer(this._container);\n        } else {\n            this._dragDropService.disableContainer(this._container);\n        }\n    }\n}\n"]}

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

@@ -1,131 +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":";AAAA,OAAO,EACL,SAAS,EACT,wBAAwB,EACxB,YAAY,EAEZ,YAAY,EAAE,UAAU,EACxB,WAAW,EACX,KAAK,EAEL,MAAM,EAEN,SAAS,EACT,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,uBAAuB,EAAC,MAAM,yCAAyC,CAAC;AAChF,OAAO,EAAC,8CAA8C,EAAC,MAAM,8BAA8B,CAAC;AAC5F,OAAO,EAAC,iBAAiB,EAAC,MAAM,kCAAkC,CAAC;AAGnE,OAAO,EAAC,YAAY,EAAC,MAAM,yCAAyC,CAAC;AA6CrE,0IAA0I;AAC1I,MAAM,OAAO,oBAAqB,SAAQ,uBAAuB;IAoE7D;IACI,+BAA+B;IAC/B,iBAAoC;IACpC,2BAA2B;IACjB,UAA4B,EAC5B,QAAkC;QAQ5C,KAAK,CAAC,iBAAiB,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;QATrC,eAAU,GAAV,UAAU,CAAkB;QAC5B,aAAQ,GAAR,QAAQ,CAA0B;QA1DhD,qBAAqB;QAEd,UAAK,GAAW,aAAa,CAAC;QAM9B,qBAAgB,GAAY,KAAK,CAAC;QAIlC,eAAU,GAAY,KAAK,CAAC;QAG5B,gBAAW,GAAY,KAAK,CAAC;QASpB,uBAAkB,GAAuB,IAAI,YAAY,EAAQ,CAAC;QAG3E,oBAAe,GAAgC,IAAI,YAAY,EAAiB,CAAC;QAGjF,eAAU,GAA6B,IAAI,YAAY,EAAc,CAAC;QAmBtE,kBAAa,GAAY,KAAK,CAAC;QAE/B,eAAU,GAAY,KAAK,CAAC;IAgBnC,CAAC;IAhFD,IACW,QAAQ,CAAC,KAAc;QAC9B,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC5B,CAAC;IA4CM,SAAS;QACd,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IACW,QAAQ;QACf,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,IACW,KAAK;QACZ,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,CAAC;IAC1D,CAAC;IAuBD,WAAW;QACP,IAAI,CAAC,gBAAgB,GAAG,SAAS,CAAC;QAClC,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC;QACvB,KAAK,CAAC,WAAW,EAAE,CAAC;IACxB,CAAC;IAEY,eAAe;;YACxB,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE;gBACxC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;aACpC;QACL,CAAC;KAAA;IAEM,cAAc;QACjB,IAAI,CAAC,eAAe,EAAE,CAAC;IAC3B,CAAC;;;YA9IJ,SAAS,SAAC;gBACP,QAAQ,EAAE,iBAAiB;gBAC3B,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgCT;gBACD,aAAa,EAAE,iBAAiB,CAAC,IAAI;gBACrC,SAAS,EAAE;oBACP;wBACI,OAAO,EAAE,8CAA8C;wBACvD,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,oBAAoB,CAAC;qBACtD;iBACJ;aACJ;;;YA/CO,iBAAiB;YALvB,gBAAgB;YAVhB,wBAAwB;;;uBAkErB,KAAK;+BAML,YAAY,SAAC,kBAAkB,EAAE,EAAC,MAAM,EAAE,IAAI,EAAC;oBAI/C,SAAS,SAAC,WAAW,EAAE,EAAC,MAAM,EAAE,IAAI,EAAC;oBAIrC,KAAK;uBAGL,KAAK;+BAGL,KAAK;yBAGL,KAAK;0BAIL,KAAK;sCAGL,KAAK;uBAGL,KAAK;iCAGL,MAAM;8BAGN,MAAM;yBAGN,MAAM;wBAIN,WAAW,SAAC,uBAAuB;uBAKnC,WAAW,SAAC,gBAAgB;oBAK5B,WAAW,SAAC,aAAa;yBAOzB,WAAW,SAAC,gBAAgB;;AAtC7B;IADC,YAAY,EAAE;wDACoB;AAGnC;IADU,YAAY,EAAE;yDACY","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"]}
+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 {\n  Component,\n  ComponentFactoryResolver,\n  ContentChild,\n  ElementRef,\n  EventEmitter, forwardRef,\n  HostBinding,\n  Input,\n  OnDestroy,\n  Output,\n  TemplateRef,\n  ViewChild,\n  ViewContainerRef,\n  ViewEncapsulation\n} from \"@angular/core\";\nimport {BaseFileUploadComponent} from \"./components/base-file-upload.component\";\nimport {SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME} from \"@colijnit/corecomponents_v12\";\nimport {DictionaryService} from \"../../service/dictionary.service\";\nimport {CoDocument} from \"@colijnit/mainapi/build/model/co-document\";\nimport {TagTreeItem} from \"@colijnit/mainapi/build/model/tag-tree-item.bo\";\nimport {InputBoolean} from \"../../decorator/input-boolean.decorator\";\n\n@Component({\n    selector: \"co-files-upload\",\n    template: `\n        <div class=\"files-upload-wrapper\">\n            <drag-drop-container\n                                 [sortableList]=\"documents\"\n                                 (sortingChange)=\"handleSortingChange($event)\"\n                                 [handleSort]=\"true\"\n                                 dragHandle=\"tile\"\n                                 [enabled]=\"!noDragDropOrdering\">\n                <co-file-upload *ngIf=\"canAdd && addWithButton\" class=\"add-file\"\n                             isAddingTile\n                             icon=\"plus_round_open\"\n                             [link]=\"true\"\n                             [label]=\"label | localize\"\n                             (mouseover)=\"mouseOverAdd = true\"\n                             (mouseout)=\"mouseOverAdd = false\"\n                             (click)=\"handleAddClick()\"></co-file-upload> <!-- (click)=\"handleAddClick()\" -->\n                <co-file-upload *ngFor=\"let file of documents\" class=\"tile\"\n                             [readonly]=\"file.readonly || readonly\"\n                             [class.hidden]=\"hideAvatars ? file.isAvatar : false\"\n                             [file]=\"file\"\n                             [label]=\"file.fileName\"\n                             [showTrashCan]=\"canDelete\"\n                             [fileSavesOnPopupOkClick]=\"fileSavesOnPopupOkClick\"\n                             [isEditable]=\"isEditable\"\n                             [customImageClick]=\"customImageClick\"\n                             (imageClick)=\"imageClick.emit($event)\"\n                             (deleteClick)=\"handleDelete(file)\"\n                             (editClick)=\"handleEditDocumentClick($event)\"></co-file-upload>\n            </drag-drop-container>\n            <span class=\"maxuploadsize\" textContent=\"getMaxFileSizeNotition()\" [class.show]=\"mouseOverAdd\"></span>\n            <input #inputFile [accept]=\"acceptedUploadFormats\" (change)=\"handleFileChange($event)\" type=\"file\" hidden multiple/>\n        </div>\n    `,\n    encapsulation: ViewEncapsulation.None,\n    providers: [\n        {\n            provide: SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME,\n            useExisting: forwardRef(() => FilesUploadComponent)\n        }\n    ]\n})\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.\nexport class FilesUploadComponent extends BaseFileUploadComponent implements OnDestroy {\n\n    @Input()\n    public set dropzone(value: boolean) {\n        this.isDropzone = value;\n    }\n\n    //todo see if this is used anywhere if not, remove\n    @ContentChild(\"slideoutTemplate\", {static: true})\n    public slideoutTemplate: TemplateRef<any>;\n\n    // (Hidden) input for file upload facilities\n    @ViewChild(\"inputFile\", {static: true})\n    public input: ElementRef;\n\n    // Input button label\n    @Input()\n    public label: string = \"UPLOAD_FILE\";\n\n    @Input()\n    public cfgNames: any;\n\n    @Input()\n    public customImageClick: boolean = false;\n\n    @Input()\n    @InputBoolean()\n    public isEditable: boolean = false;\n\n    @Input() @InputBoolean()\n    public hideAvatars: boolean = false;\n\n    @Input()\n    public fileSavesOnPopupOkClick: string;\n\n    @Input()\n    public selected: string;\n\n    @Output()\n    public readonly editSlideoutSubmit: EventEmitter<void> = new EventEmitter<void>();\n\n    @Output()\n    public tagsChangeEvent: EventEmitter<TagTreeItem[]> = new EventEmitter<TagTreeItem[]>();\n\n    @Output()\n    public imageClick: EventEmitter<CoDocument> = new EventEmitter<CoDocument>();\n\n\n    @HostBinding('class.co-files-upload')\n    public showClass() {\n      return true;\n    }\n\n    @HostBinding(\"class.editable\")\n    public get editable(): boolean {\n        return this.canAdd;\n    }\n\n    @HostBinding(\"class.empty\")\n    public get empty(): boolean {\n        return !this.documents || this.documents.length === 0;\n    }\n\n    public mouseOverAdd: boolean;\n    public slideoutShown: boolean = false;\n    @HostBinding('class.dropzone')\n    public isDropzone: boolean = false;\n\n    constructor(\n        //promptService: PromptService,\n        dictionaryService: DictionaryService,\n        //userService: UserService,\n        protected _container: ViewContainerRef,\n        protected _factory: ComponentFactoryResolver,\n        //protected _dataService: DataService,\n        //protected _baseDataDalRepository: BaseDataDalRepository,\n       // protected _generalDalRepository: GeneralDalRepository,\n        //protected _coDocumentDataLoader: CoDocumentDataLoaderService,\n        //private _workability: AppWorkabilityService,\n        //private _fileTypeImgPipe: FileTypeImagePipe\n    ) {\n        super(dictionaryService, _container, _factory);\n    }\n\n    ngOnDestroy(): void {\n        this.slideoutTemplate = undefined;\n        this.input = undefined;\n        super.ngOnDestroy();\n    }\n\n    public async openFileBrowser(): Promise<void> {\n        if (this.input && this.input.nativeElement) {\n            this.input.nativeElement.click();\n        }\n    }\n\n    public handleAddClick(): void {\n        this.openFileBrowser();\n    }\n\n    //todo check if this can be removed at the end of the run\n    /*public onCustomClose(): void {\n        this.documentUnderEdit = undefined;\n    }*/\n}\n"]}