@colijnit/sharedcomponents 1.0.57 → 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":"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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"]}

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

package/esm2015/lib/components/multi-property-toggler/multiple-property-toggler.component.js

@@ -0,0 +1,89 @@
+/**
+ * Custom component for enabling and disabling multiple items based on an input enum
+ * For the component to work, an enum is required and a list of enabled items so that
+ * the component knows which items from the enum are already enabled
+ *
+ * Note: can be improved by not only accepting a string array of enabledItemProperties but also a full cgref number because that will save one conversion step as
+ * BO's already contain these numbers.
+ */
+import { Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from "@angular/core";
+import { Icon } from "../../enum/icon.enum";
+import { RefCodeUtils } from "../../utils/ref-code-utils";
+import { EnumUtils } from "../../utils/enum-utils";
+export class MultiplePropertyTogglerComponent {
+    constructor() {
+        this.label = "";
+        this.readonly = false;
+        this.enableditemsChange = new EventEmitter();
+        // Outputs the sum of cgrefkeys of all newly enabled items
+        this.onPropertyItemChange = new EventEmitter();
+        this.Icons = Icon;
+        this.objectifiedEnum = [];
+        this.enabledItemNumberList = [];
+    }
+    showClass() {
+        return true;
+    }
+    ngAfterViewInit() {
+        if (this.propertyNamesToToggle) {
+            this.objectifiedEnum = EnumUtils.createObjectFromEnum(this.propertyNamesToToggle);
+        }
+        else {
+            // PropertytogglerItems is empty
+        }
+        this.makeNumberArrayFromCgRefCodeSum();
+    }
+    isValueActive(propertyToCheck) {
+        return this.enabledItemNumberList.includes(propertyToCheck.key);
+    }
+    clickToToggleProperty(target) {
+        let newRefNumberSum = 0;
+        if (this.enabledItemNumberList.includes(target.key)) {
+            this.enabledItemNumberList.splice(this.enabledItemNumberList.indexOf(target.key), 1);
+        }
+        else {
+            this.enabledItemNumberList.push(target.key);
+        }
+        this.enabledItemNumberList.forEach(enabledItem => {
+            newRefNumberSum += this.objectifiedEnum.find(x => x.key === enabledItem).key;
+        });
+        this.onPropertyItemChange.emit(newRefNumberSum);
+    }
+    makeNumberArrayFromCgRefCodeSum() {
+        if (this.enableditems) {
+            this.enabledItemNumberList = RefCodeUtils.GetMultiRefCodeChoices(this.enableditems);
+        }
+    }
+}
+MultiplePropertyTogglerComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-multiple-property-toggler",
+                template: `
+        <div class="input-text-content-wrapper">
+            <h3 [textContent]="label"></h3> <!-- | localize-->
+
+            <div class="property-toggling-container">
+
+                <div class="row" *ngFor="let propertyTogglerItem of objectifiedEnum | keyvalue">
+
+                    <co-input-checkbox [model]="isValueActive(propertyTogglerItem.value)"
+                                     (click)="clickToToggleProperty(propertyTogglerItem.value)"></co-input-checkbox>
+
+                    <label [textContent]="propertyTogglerItem.value.value"></label>
+                </div>
+            </div>
+        </div>
+    `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+MultiplePropertyTogglerComponent.propDecorators = {
+    label: [{ type: Input }],
+    propertyNamesToToggle: [{ type: Input }],
+    readonly: [{ type: Input }],
+    enableditems: [{ type: Input }],
+    enableditemsChange: [{ type: Output }],
+    onPropertyItemChange: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.co-multiple-property-toggler",] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multiple-property-toggler.component.js","sourceRoot":"","sources":["../../../../../../projects/sharedcomponents/src/lib/components/multi-property-toggler/multiple-property-toggler.component.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAgB,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAC,MAAM,eAAe,CAAC;AAGpH,OAAO,EAAC,IAAI,EAAC,MAAM,sBAAsB,CAAC;AAC1C,OAAO,EAAC,YAAY,EAAC,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAC,SAAS,EAAC,MAAM,wBAAwB,CAAC;AAsBjD,MAAM,OAAO,gCAAgC;IApB7C;QAsBW,UAAK,GAAW,EAAE,CAAC;QAOnB,aAAQ,GAAa,KAAK,CAAC;QAO3B,uBAAkB,GAAyB,IAAI,YAAY,EAAU,CAAC;QAE7E,0DAA0D;QAE1C,yBAAoB,GAAyB,IAAI,YAAY,EAAU,CAAC;QAOxE,UAAK,GAAgB,IAAI,CAAC;QAEnC,oBAAe,GAAmB,EAAE,CAAC;QAErC,0BAAqB,GAAa,EAAE,CAAC;IAsChD,CAAC;IA9CU,SAAS;QACd,OAAO,IAAI,CAAC;IACd,CAAC;IAQD,eAAe;QACX,IAAI,IAAI,CAAC,qBAAqB,EAAE;YAC5B,IAAI,CAAC,eAAe,GAAG,SAAS,CAAC,oBAAoB,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;SACrF;aAAM;YACH,gCAAgC;SACnC;QACD,IAAI,CAAC,+BAA+B,EAAE,CAAC;IAC3C,CAAC;IAEM,aAAa,CAAC,eAAoB;QACrC,OAAO,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;IACpE,CAAC;IAEM,qBAAqB,CAAC,MAAW;QACpC,IAAI,eAAe,GAAW,CAAC,CAAC;QAEhC,IAAI,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE;YACjD,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;SACxF;aAAM;YACH,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;SAC/C;QAED,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAC9B,WAAW,CAAC,EAAE;YACV,eAAe,IAAI,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,WAAW,CAAC,CAAC,GAAG,CAAC;QACjF,CAAC,CACJ,CAAC;QAEF,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IACpD,CAAC;IAEM,+BAA+B;QAClC,IAAI,IAAI,CAAC,YAAY,EAAE;YACnB,IAAI,CAAC,qBAAqB,GAAG,YAAY,CAAC,sBAAsB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;SACvF;IACL,CAAC;;;YAxFJ,SAAS,SAAC;gBACP,QAAQ,EAAE,8BAA8B;gBACxC,QAAQ,EAAE;;;;;;;;;;;;;;;KAeT;gBACD,aAAa,EAAE,iBAAiB,CAAC,IAAI;aACxC;;;oBAEI,KAAK;oCAIL,KAAK;uBAGL,KAAK;2BAIL,KAAK;iCAGL,MAAM;mCAIN,MAAM;wBAGN,WAAW,SAAC,oCAAoC","sourcesContent":["/**\r\n * Custom component for enabling and disabling multiple items based on an input enum\r\n * For the component to work, an enum is required and a list of enabled items so that\r\n * the component knows which items from the enum are already enabled\r\n *\r\n * Note: can be improved by not only accepting a string array of enabledItemProperties but also a full cgref number because that will save one conversion step as\r\n * BO's already contain these numbers.\r\n */\r\n\r\nimport {AfterViewInit, Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation} from \"@angular/core\";\r\n//import {EnumUtils} from \"../../utils/enum-utils\";\r\nimport {KeyValuePair} from \"../../interface/key-value-pair\";\r\nimport {Icon} from \"../../enum/icon.enum\";\r\nimport {RefCodeUtils} from \"../../utils/ref-code-utils\";\r\nimport {EnumUtils} from \"../../utils/enum-utils\";\r\n\r\n@Component({\r\n    selector: \"co-multiple-property-toggler\",\r\n    template: `\r\n        <div class=\"input-text-content-wrapper\">\r\n            <h3 [textContent]=\"label\"></h3> <!-- | localize-->\r\n\r\n            <div class=\"property-toggling-container\">\r\n\r\n                <div class=\"row\" *ngFor=\"let propertyTogglerItem of objectifiedEnum | keyvalue\">\r\n\r\n                    <co-input-checkbox [model]=\"isValueActive(propertyTogglerItem.value)\"\r\n                                     (click)=\"clickToToggleProperty(propertyTogglerItem.value)\"></co-input-checkbox>\r\n\r\n                    <label [textContent]=\"propertyTogglerItem.value.value\"></label>\r\n                </div>\r\n            </div>\r\n        </div>\r\n    `,\r\n    encapsulation: ViewEncapsulation.None\r\n})\r\nexport class MultiplePropertyTogglerComponent implements AfterViewInit {\r\n    @Input()\r\n    public label: string = \"\";\r\n\r\n    // Input an Enum with names and properties and it will be converted\r\n    @Input()\r\n    public propertyNamesToToggle: any;\r\n\r\n    @Input()\r\n    public readonly : boolean = false;\r\n\r\n    // Input the cgrefcode sum so it knows which items will be enabled\r\n    @Input()\r\n    public enableditems: number;\r\n\r\n    @Output()\r\n    public enableditemsChange: EventEmitter<number> = new EventEmitter<number>();\r\n\r\n    // Outputs the sum of cgrefkeys of all newly enabled items\r\n    @Output()\r\n    public readonly onPropertyItemChange: EventEmitter<number> = new EventEmitter<number>();\r\n\r\n    @HostBinding(\"class.co-multiple-property-toggler\")\r\n    public showClass(): boolean {\r\n      return true;\r\n    }\r\n\r\n    public readonly Icons: typeof Icon = Icon;\r\n\r\n    public objectifiedEnum: KeyValuePair[] = [];\r\n\r\n    public enabledItemNumberList: number[] = [];\r\n\r\n    ngAfterViewInit(): void {\r\n        if (this.propertyNamesToToggle) {\r\n            this.objectifiedEnum = EnumUtils.createObjectFromEnum(this.propertyNamesToToggle);\r\n        } else {\r\n            // PropertytogglerItems is empty\r\n        }\r\n        this.makeNumberArrayFromCgRefCodeSum();\r\n    }\r\n\r\n    public isValueActive(propertyToCheck: any): boolean {\r\n        return this.enabledItemNumberList.includes(propertyToCheck.key);\r\n    }\r\n\r\n    public clickToToggleProperty(target: any): void {\r\n        let newRefNumberSum: number = 0;\r\n\r\n        if (this.enabledItemNumberList.includes(target.key)) {\r\n            this.enabledItemNumberList.splice(this.enabledItemNumberList.indexOf(target.key), 1);\r\n        } else {\r\n            this.enabledItemNumberList.push(target.key);\r\n        }\r\n\r\n        this.enabledItemNumberList.forEach(\r\n            enabledItem => {\r\n                newRefNumberSum += this.objectifiedEnum.find(x => x.key === enabledItem).key;\r\n            }\r\n        );\r\n\r\n        this.onPropertyItemChange.emit(newRefNumberSum);\r\n    }\r\n\r\n    public makeNumberArrayFromCgRefCodeSum(): void {\r\n        if (this.enableditems) {\r\n            this.enabledItemNumberList = RefCodeUtils.GetMultiRefCodeChoices(this.enableditems);\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2015/lib/components/multi-property-toggler/multiple-property-toggler.module.js

@@ -0,0 +1,21 @@
+import { NgModule } from "@angular/core";
+import { MultiplePropertyTogglerComponent } from "./multiple-property-toggler.component";
+import { InputCheckboxModule } from "@colijnit/corecomponents_v12";
+import { CommonModule } from "@angular/common";
+export class MultiplePropertyTogglerModule {
+}
+MultiplePropertyTogglerModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    InputCheckboxModule,
+                    CommonModule
+                ],
+                declarations: [
+                    MultiplePropertyTogglerComponent
+                ],
+                exports: [
+                    MultiplePropertyTogglerComponent
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXVsdGlwbGUtcHJvcGVydHktdG9nZ2xlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zaGFyZWRjb21wb25lbnRzL3NyYy9saWIvY29tcG9uZW50cy9tdWx0aS1wcm9wZXJ0eS10b2dnbGVyL211bHRpcGxlLXByb3BlcnR5LXRvZ2dsZXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFDLGdDQUFnQyxFQUFDLE1BQU0sdUNBQXVDLENBQUM7QUFDdkYsT0FBTyxFQUFDLG1CQUFtQixFQUFDLE1BQU0sOEJBQThCLENBQUM7QUFDakUsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBYzdDLE1BQU0sT0FBTyw2QkFBNkI7OztZQVp6QyxRQUFRLFNBQUM7Z0JBQ1IsT0FBTyxFQUFFO29CQUNQLG1CQUFtQjtvQkFDbkIsWUFBWTtpQkFDYjtnQkFDRCxZQUFZLEVBQUU7b0JBQ2QsZ0NBQWdDO2lCQUMvQjtnQkFDRCxPQUFPLEVBQUU7b0JBQ1QsZ0NBQWdDO2lCQUMvQjthQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHtNdWx0aXBsZVByb3BlcnR5VG9nZ2xlckNvbXBvbmVudH0gZnJvbSBcIi4vbXVsdGlwbGUtcHJvcGVydHktdG9nZ2xlci5jb21wb25lbnRcIjtcclxuaW1wb3J0IHtJbnB1dENoZWNrYm94TW9kdWxlfSBmcm9tIFwiQGNvbGlqbml0L2NvcmVjb21wb25lbnRzX3YxMlwiO1xyXG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vblwiO1xyXG5cclxuQE5nTW9kdWxlKHtcclxuICBpbXBvcnRzOiBbXHJcbiAgICBJbnB1dENoZWNrYm94TW9kdWxlLFxyXG4gICAgQ29tbW9uTW9kdWxlXHJcbiAgXSxcclxuICBkZWNsYXJhdGlvbnM6IFtcclxuICBNdWx0aXBsZVByb3BlcnR5VG9nZ2xlckNvbXBvbmVudFxyXG4gIF0sXHJcbiAgZXhwb3J0czogW1xyXG4gIE11bHRpcGxlUHJvcGVydHlUb2dnbGVyQ29tcG9uZW50XHJcbiAgXVxyXG59KVxyXG5leHBvcnQgY2xhc3MgTXVsdGlwbGVQcm9wZXJ0eVRvZ2dsZXJNb2R1bGUge1xyXG5cclxufVxyXG4iXX0=

package/esm2015/lib/components/tile-renderer/tile-render.component.js

@@ -0,0 +1,80 @@
+import { Component, ContentChild, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from "@angular/core";
+import { TileSizeType } from "../../enum/tile-size-type";
+import { Icon } from "../../enum/icon.enum";
+import { IconCacheService } from "../../service/icon-cache.service";
+/**
+ * A generic component that shows a collection of simple inputs (description, image, price, etc.) as a tile-shaped graphic with an image
+ * part (upper) and an info part (lower).
+ */
+export class TileRenderComponent {
+    constructor(iconCacheService) {
+        this.iconCacheService = iconCacheService;
+        this.icons = Icon;
+        // Render a large or small tile.
+        this.tileSize = TileSizeType.Large;
+        // When this tile is selected, this icon will be shown green in the upper-left corner (defaults to 'check').
+        this.iconWhenSelected = "check";
+        // Emits when the image wrapper was clicked (top half of this component) .
+        this.imageClick = new EventEmitter();
+        // Emits when the info wrapper was clicked (bottom half of this component).
+        this.infoClick = new EventEmitter();
+        this.Icon = Icon;
+    }
+    get inSmallTileMode() {
+        return this.tileSize === TileSizeType.Small;
+    }
+    showClass() {
+        return true;
+    }
+    get inLargeTileMode() {
+        return this.tileSize === TileSizeType.Large;
+    }
+    ngOnDestroy() {
+        this.infoTemplate = undefined;
+    }
+}
+TileRenderComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-tile-render",
+                template: `
+        <div class="image" (click)="imageClick.emit()">
+            <label *ngIf="inLargeTileMode && tagDescription" [textContent]="tagDescription"></label>
+            <co-icon *ngIf="selected" class="selected small light circle" [iconData]="iconCacheService.getIcon(iconWhenSelected)" ></co-icon>
+            <co-image [source]="imageDataUri" [class.hidden]="(inSmallTileMode || hideImageDisplayWhenNoImage) && !imageDataUri"
+            ></co-image>
+
+
+
+            <ng-content select="[tile-render-image-content]"></ng-content>
+        </div>
+        <div class="info" (click)="infoClick.emit()">
+            <ng-container *ngIf="infoTemplate" [templateWrapper]="infoTemplate"></ng-container>
+            <span *ngIf="inLargeTileMode && label" class="label" [textContent]="label"></span>
+            <span *ngIf="inLargeTileMode && description" class="description" [textContent]="description"></span>
+        </div>
+        <ng-content></ng-content>
+    `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+TileRenderComponent.ctorParameters = () => [
+    { type: IconCacheService }
+];
+TileRenderComponent.propDecorators = {
+    infoTemplate: [{ type: ContentChild, args: ["infoTemplate", { static: true },] }],
+    imageDataUri: [{ type: Input }],
+    tagDescription: [{ type: Input }],
+    label: [{ type: Input }],
+    description: [{ type: Input }],
+    tileSize: [{ type: Input }],
+    price: [{ type: Input }],
+    hidePrice: [{ type: Input }],
+    iconWhenSelected: [{ type: Input }],
+    hideImageDisplayWhenNoImage: [{ type: Input }],
+    selected: [{ type: Input }, { type: HostBinding, args: ["class.selected",] }],
+    imageClick: [{ type: Output }],
+    infoClick: [{ type: Output }],
+    inSmallTileMode: [{ type: HostBinding, args: ["class.small-size",] }],
+    showClass: [{ type: HostBinding, args: ["class.co-tile-render",] }]
+};
+//# sourceMappingURL=data:application/json;base64,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