slick-components 4.4.13 → 4.4.16

package/esm2020/slick-file-drop/slick-file-drop.component.mjs

@@ -0,0 +1,156 @@
+import { Component, Input, Output, EventEmitter, ViewChild, HostListener } from "@angular/core";
+import { SlickUtilsService } from "../utils/slick-utils.service";
+import { SlickFileModel } from "../slick-file-model/slick-file.model";
+import * as i0 from "@angular/core";
+const imgExtensions = ['bmp', 'gif', 'jpeg', 'jpg', 'png', 'tif', 'tiff'];
+export class SlickFileDropComponent {
+    constructor() {
+        this.displayText = "Drop Files Here...";
+        this.filesChangedEmitter = new EventEmitter();
+        this.fnOnFileInputChange = (e) => this.onFileInputChange(e);
+        this.uuid = SlickUtilsService.newGuid();
+    }
+    onClick(e) {
+        this.fileInput.nativeElement.click();
+        this.fileInput.nativeElement.removeEventListener("change", this.fnOnFileInputChange, true);
+        this.fileInput.nativeElement.addEventListener("change", this.fnOnFileInputChange, true);
+    }
+    ngOnDestroy() {
+        this.fileInput.nativeElement.removeEventListener("change", this.fnOnFileInputChange, true);
+    }
+    onFileInputChange(e) {
+        try {
+            this.processFileTimeout = setTimeout(() => {
+                alert("Processing files timed out");
+            }, 10000);
+            this.processFiles(this.fileInput.nativeElement.files);
+            // A validation to make sure the files all got processed
+            clearTimeout(this.processFileTimeout);
+            this.fileInput.nativeElement.value = '';
+        }
+        catch (err) {
+            alert("SlickFileDrop Error: " + err);
+        }
+    }
+    onDrop(e) {
+        e.preventDefault();
+        e.stopPropagation();
+        this.containerRef.nativeElement.classList.remove("slick-file-drop_drag-enter");
+        this.processFiles(e.dataTransfer.files);
+    }
+    onDragEnter(e) {
+        this.containerRef.nativeElement.classList.add("slick-file-drop_drag-enter");
+    }
+    onDragOver(e) {
+        e.preventDefault();
+    }
+    onDragLeave(e) {
+        this.containerRef.nativeElement.classList.remove("slick-file-drop_drag-enter");
+    }
+    async processFiles(files) {
+        let slickFileModels = [];
+        let imageLoadPromises = [];
+        let imgPromises = [];
+        for (let i = 0; i < files.length; i++) {
+            imageLoadPromises.push(new Promise(async (resolve) => {
+                let file = files.item(i);
+                let slickFileModel = new SlickFileModel();
+                slickFileModel.uuid = SlickUtilsService.newGuid();
+                slickFileModel.file = file;
+                slickFileModel.name = file.name;
+                slickFileModel.title = file.name;
+                let fileNameParts = slickFileModel.name.split('.');
+                let ext = fileNameParts[fileNameParts.length - 1].toLowerCase();
+                if (imgExtensions.indexOf(ext) >= 0) {
+                    let img = new Image;
+                    img.onload = () => {
+                        slickFileModel.thumbnailBase64Image = this.resizeImageToBase64(img, 60, 60);
+                        slickFileModel.base64Image = this.resizeImageToBase64(img, 1600, 1600);
+                        slickFileModels.push(slickFileModel);
+                        resolve(null);
+                    };
+                    img.src = await this.getBase64(file);
+                }
+                else {
+                    slickFileModels.push(slickFileModel);
+                    resolve(null);
+                }
+            }));
+        }
+        await Promise.all(imageLoadPromises);
+        this.filesChangedEmitter.emit(slickFileModels);
+    }
+    resizeImageToBase64(img, width, height) {
+        let scale = 1;
+        if (img.width > img.height) {
+            if (img.width > width)
+                scale = width / img.width;
+        }
+        else {
+            if (img.height > height)
+                scale = height / img.height;
+        }
+        let newWidth = img.width * scale;
+        let newHeight = img.height * scale;
+        // We create a canvas and get its context.
+        var canvas = document.createElement('canvas');
+        var ctx = canvas.getContext('2d');
+        // We set the dimensions at the wanted size.
+        canvas.width = newWidth;
+        canvas.height = newHeight;
+        // We resize the image with the canvas method drawImage();
+        ctx.drawImage(img, 0, 0, newWidth, newHeight);
+        return canvas.toDataURL("image/jpeg");
+    }
+    getBase64(file) {
+        return new Promise((resolve, reject) => {
+            // Capacitor fails on the FileReader, so we need to get _readReader
+            // See: https://github.com/ionic-team/ionic-native/issues/505#issuecomment-503316333
+            let fileReader = new FileReader();
+            // Get the original real FileReader. The polyfill saves a reference to it.
+            const realFileReader = fileReader._realReader;
+            // Make sure we were able to get the original FileReader 
+            if (realFileReader) {
+                // Swap out the polyfill instance for the original instance.
+                fileReader = realFileReader;
+            }
+            fileReader.readAsDataURL(file);
+            fileReader.onload = () => resolve(fileReader.result);
+            fileReader.onerror = (error) => reject('Error: ' + error);
+        });
+    }
+}
+/** @nocollapse */ SlickFileDropComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickFileDropComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ SlickFileDropComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.3", type: SlickFileDropComponent, selector: "slick-file-drop", inputs: { displayText: "displayText" }, outputs: { filesChangedEmitter: "filesChanged" }, host: { listeners: { "click": "onClick($event)", "drop": "onDrop($event)", "dragenter": "onDragEnter($event)", "dragover": "onDragOver($event)", "dragleave": "onDragLeave($event)" } }, viewQueries: [{ propertyName: "containerRef", first: true, predicate: ["containerRef"], descendants: true }, { propertyName: "fileInput", first: true, predicate: ["fileInput"], descendants: true }], ngImport: i0, template: "<p #containerRef id=\"slick-file-drop_{{uuid}}\" class=\"slick-file-drop card\">\r\n\t{{displayText}}\r\n</p>\r\n<input type=\"file\" #fileInput style=\"display: none\" multiple />\r\n" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickFileDropComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'slick-file-drop', template: "<p #containerRef id=\"slick-file-drop_{{uuid}}\" class=\"slick-file-drop card\">\r\n\t{{displayText}}\r\n</p>\r\n<input type=\"file\" #fileInput style=\"display: none\" multiple />\r\n" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { displayText: [{
+                type: Input,
+                args: ["displayText"]
+            }], filesChangedEmitter: [{
+                type: Output,
+                args: ["filesChanged"]
+            }], containerRef: [{
+                type: ViewChild,
+                args: ["containerRef"]
+            }], fileInput: [{
+                type: ViewChild,
+                args: ["fileInput"]
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], onDrop: [{
+                type: HostListener,
+                args: ['drop', ['$event']]
+            }], onDragEnter: [{
+                type: HostListener,
+                args: ['dragenter', ['$event']]
+            }], onDragOver: [{
+                type: HostListener,
+                args: ['dragover', ['$event']]
+            }], onDragLeave: [{
+                type: HostListener,
+                args: ['dragleave', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slick-file-drop.component.js","sourceRoot":"","sources":["../../../../projects/components/src/slick-file-drop/slick-file-drop.component.ts","../../../../projects/components/src/slick-file-drop/slick-file-drop.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, ElementRef, ViewChild, HostListener, OnDestroy } from \"@angular/core\";\r\nimport { SlickUtilsService } from \"../utils/slick-utils.service\";\r\nimport { ISlickFileModel, SlickFileModel } from \"../slick-file-model/slick-file.model\";\r\n\r\nconst imgExtensions: string[] = ['bmp', 'gif', 'jpeg', 'jpg', 'png', 'tif', 'tiff']\r\n\r\n@Component({\r\n\tselector: 'slick-file-drop',\r\n\ttemplateUrl: 'slick-file-drop.component.html'\r\n})\r\nexport class SlickFileDropComponent implements OnDestroy {\r\n\t@Input(\"displayText\") displayText: string = \"Drop Files Here...\";\r\n\t@Output(\"filesChanged\") filesChangedEmitter: EventEmitter<ISlickFileModel[]> = new EventEmitter();\r\n\t@ViewChild(\"containerRef\") containerRef: ElementRef;\r\n\t@ViewChild(\"fileInput\") fileInput: ElementRef;\r\n\r\n\tprivate fnOnFileInputChange = (e) => this.onFileInputChange(e);\r\n\tprivate processFileTimeout: NodeJS.Timer;\r\n\r\n\t@HostListener('click', ['$event'])\r\n\tonClick(e) {\r\n\t\tthis.fileInput.nativeElement.click();\r\n\t\t(<HTMLInputElement>this.fileInput.nativeElement).removeEventListener(\"change\", this.fnOnFileInputChange, true);\r\n\t\t(<HTMLInputElement>this.fileInput.nativeElement).addEventListener(\"change\", this.fnOnFileInputChange, true);\r\n\t}\r\n\r\n\tngOnDestroy() {\r\n\t\t(<HTMLInputElement>this.fileInput.nativeElement).removeEventListener(\"change\", this.fnOnFileInputChange, true);\r\n\t}\r\n\r\n\tprivate onFileInputChange(e) {\r\n\t\ttry {\r\n\t\t\tthis.processFileTimeout = setTimeout(() => {\r\n\t\t\t\talert(\"Processing files timed out\");\r\n\t\t\t}, 10000);\r\n\r\n\t\t\tthis.processFiles((<HTMLInputElement>this.fileInput.nativeElement).files);\r\n\r\n\t\t\t// A validation to make sure the files all got processed\r\n\t\t\tclearTimeout(this.processFileTimeout);\r\n\t\t\t(<HTMLInputElement>this.fileInput.nativeElement).value = '';\r\n\t\t}\r\n\t\tcatch (err) {\r\n\t\t\talert(\"SlickFileDrop Error: \" + err);\r\n\t\t}\r\n\t}\r\n\r\n\t@HostListener('drop', ['$event'])\r\n\tonDrop(e) {\r\n\t\te.preventDefault();\r\n\t\te.stopPropagation();\r\n\r\n\t\tthis.containerRef.nativeElement.classList.remove(\"slick-file-drop_drag-enter\");\r\n\r\n\t\tthis.processFiles((<DataTransfer>e.dataTransfer).files);\r\n\t}\r\n\r\n\t@HostListener('dragenter', ['$event'])\r\n\tonDragEnter(e) {\r\n\t\tthis.containerRef.nativeElement.classList.add(\"slick-file-drop_drag-enter\");\r\n\t}\r\n\r\n\t@HostListener('dragover', ['$event'])\r\n\tonDragOver(e) {\r\n\t\te.preventDefault();\r\n\t}\r\n\r\n\t@HostListener('dragleave', ['$event'])\r\n\tonDragLeave(e) {\r\n\t\tthis.containerRef.nativeElement.classList.remove(\"slick-file-drop_drag-enter\");\r\n\t}\r\n\r\n\tuuid: string;\r\n\r\n\tconstructor() {\r\n\t\tthis.uuid = SlickUtilsService.newGuid();\r\n\t}\r\n\r\n\tprivate async processFiles(files: FileList) {\r\n\t\tlet slickFileModels: ISlickFileModel[] = [];\r\n\t\tlet imageLoadPromises = [];\r\n\r\n\t\tlet imgPromises: Promise<string>[] = [];\r\n\t\tfor (let i = 0; i < files.length; i++) {\r\n\t\t\timageLoadPromises.push(new Promise(async (resolve) => {\r\n\t\t\t\tlet file: File = files.item(i);\r\n\t\t\t\tlet slickFileModel = new SlickFileModel();\r\n\t\t\t\tslickFileModel.uuid = SlickUtilsService.newGuid();\r\n\t\t\t\tslickFileModel.file = file;\r\n\t\t\t\tslickFileModel.name = file.name;\r\n\t\t\t\tslickFileModel.title = file.name;\r\n\r\n\t\t\t\tlet fileNameParts = slickFileModel.name.split('.');\r\n\t\t\t\tlet ext = fileNameParts[fileNameParts.length - 1].toLowerCase();\r\n\r\n\t\t\t\tif (imgExtensions.indexOf(ext) >= 0) {\r\n\t\t\t\t\tlet img = new Image;\r\n\t\t\t\t\timg.onload = () => {\t\r\n\t\t\t\t\t\tslickFileModel.thumbnailBase64Image = this.resizeImageToBase64(img, 60, 60);\r\n\t\t\t\t\t\tslickFileModel.base64Image = this.resizeImageToBase64(img, 1600, 1600);\r\n\t\t\t\t\t\tslickFileModels.push(slickFileModel);\r\n\t\t\t\t\t\tresolve(null);\r\n\t\t\t\t\t}\r\n\t\t\t\t\timg.src = await this.getBase64(file);\r\n\t\t\t\t}\r\n\t\t\t\telse {\r\n\t\t\t\t\tslickFileModels.push(slickFileModel);\r\n\t\t\t\t\tresolve(null);\r\n\t\t\t\t}\r\n\t\t\t}));\r\n\t\t}\r\n\r\n\t\tawait Promise.all(imageLoadPromises);\r\n\t\tthis.filesChangedEmitter.emit(slickFileModels);\r\n\t}\r\n\r\n\tprivate resizeImageToBase64(img: HTMLImageElement, width: number, height: number): string {\r\n\t\tlet scale: number = 1;\r\n\t\tif (img.width > img.height) {\r\n\t\t\tif (img.width > width)\r\n\t\t\t\tscale = width / img.width;\r\n\t\t}\r\n\t\telse {\r\n\t\t\tif (img.height > height)\r\n\t\t\t\tscale = height / img.height;\r\n\t\t}\r\n\r\n\t\tlet newWidth = img.width * scale;\r\n\t\tlet newHeight = img.height * scale;\r\n\r\n\t\t// We create a canvas and get its context.\r\n\t\tvar canvas = document.createElement('canvas');\r\n\t\tvar ctx = canvas.getContext('2d');\r\n\r\n\t\t// We set the dimensions at the wanted size.\r\n\t\tcanvas.width = newWidth;\r\n\t\tcanvas.height = newHeight;\r\n\r\n\t\t// We resize the image with the canvas method drawImage();\r\n\t\tctx.drawImage(img, 0, 0, newWidth, newHeight);\r\n\r\n\t\treturn canvas.toDataURL(\"image/jpeg\");\r\n\t}\r\n\r\n\tprivate getBase64(file: File): Promise<string> {\r\n\t\treturn new Promise<string>((resolve, reject) => {\r\n\t\t\t// Capacitor fails on the FileReader, so we need to get _readReader\r\n\t\t\t// See: https://github.com/ionic-team/ionic-native/issues/505#issuecomment-503316333\r\n\t\t\tlet fileReader = new FileReader();\r\n\r\n\t\t\t// Get the original real FileReader. The polyfill saves a reference to it.\r\n\t\t\tconst realFileReader = (fileReader as any)._realReader;\r\n\r\n\t\t\t// Make sure we were able to get the original FileReader \r\n\t\t\tif (realFileReader) {\r\n\t\t\t\t// Swap out the polyfill instance for the original instance.\r\n\t\t\t\tfileReader = realFileReader;\r\n\t\t\t}\r\n\r\n\t\t\tfileReader.readAsDataURL(file);\r\n\t\t\tfileReader.onload = () => resolve(<string>fileReader.result);\r\n\t\t\tfileReader.onerror = (error) => reject('Error: ' + error);\r\n\t\t});\r\n\t}\r\n}\r\n","<p #containerRef id=\"slick-file-drop_{{uuid}}\" class=\"slick-file-drop card\">\r\n\t{{displayText}}\r\n</p>\r\n<input type=\"file\" #fileInput style=\"display: none\" multiple />\r\n"]}

package/esm2020/slick-file-drop/slick-file-drop.module.mjs

@@ -0,0 +1,20 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from "@angular/core";
+import { FormsModule } from "@angular/forms";
+import { SlickFileDropComponent } from "./slick-file-drop.component";
+import * as i0 from "@angular/core";
+export class SlickFileDropModule {
+}
+/** @nocollapse */ SlickFileDropModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickFileDropModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ SlickFileDropModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickFileDropModule, declarations: [SlickFileDropComponent], imports: [CommonModule, FormsModule], exports: [CommonModule, FormsModule, SlickFileDropComponent] });
+/** @nocollapse */ SlickFileDropModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickFileDropModule, imports: [[CommonModule, FormsModule], CommonModule, FormsModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickFileDropModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, FormsModule],
+                    declarations: [SlickFileDropComponent],
+                    exports: [CommonModule, FormsModule, SlickFileDropComponent]
+                }]
+        }] });
+export { SlickFileDropComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpY2stZmlsZS1kcm9wLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvc3JjL3NsaWNrLWZpbGUtZHJvcC9zbGljay1maWxlLWRyb3AubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUM3QyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQzs7QUFPckUsTUFBTSxPQUFPLG1CQUFtQjs7bUlBQW5CLG1CQUFtQjtvSUFBbkIsbUJBQW1CLGlCQUhoQixzQkFBc0IsYUFEM0IsWUFBWSxFQUFFLFdBQVcsYUFFekIsWUFBWSxFQUFFLFdBQVcsRUFBRSxzQkFBc0I7b0lBRS9DLG1CQUFtQixZQUp0QixDQUFDLFlBQVksRUFBRSxXQUFXLENBQUMsRUFFMUIsWUFBWSxFQUFFLFdBQVc7MkZBRXZCLG1CQUFtQjtrQkFML0IsUUFBUTttQkFBQztvQkFDVCxPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsV0FBVyxDQUFDO29CQUNwQyxZQUFZLEVBQUUsQ0FBQyxzQkFBc0IsQ0FBQztvQkFDdEMsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLFdBQVcsRUFBRSxzQkFBc0IsQ0FBQztpQkFDNUQ7O0FBRUQsT0FBTyxFQUFFLHNCQUFzQixFQUFFLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xyXG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7IEZvcm1zTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2Zvcm1zXCI7XHJcbmltcG9ydCB7IFNsaWNrRmlsZURyb3BDb21wb25lbnQgfSBmcm9tIFwiLi9zbGljay1maWxlLWRyb3AuY29tcG9uZW50XCI7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG5cdGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIEZvcm1zTW9kdWxlXSxcclxuXHRkZWNsYXJhdGlvbnM6IFtTbGlja0ZpbGVEcm9wQ29tcG9uZW50XSxcclxuXHRleHBvcnRzOiBbQ29tbW9uTW9kdWxlLCBGb3Jtc01vZHVsZSwgU2xpY2tGaWxlRHJvcENvbXBvbmVudF1cclxufSlcclxuZXhwb3J0IGNsYXNzIFNsaWNrRmlsZURyb3BNb2R1bGUgeyB9XHJcbmV4cG9ydCB7IFNsaWNrRmlsZURyb3BDb21wb25lbnQgfVxyXG4iXX0=

package/esm2020/slick-file-list/slick-file-list-item.component.mjs

@@ -0,0 +1,173 @@
+import { Component, Input, Output, ViewChild, EventEmitter } from "@angular/core";
+import { SlickSleepService } from "../utils/slick-sleep.service";
+import { SlickUtilsService } from "../utils/slick-utils.service";
+import { SlickConfirmDialogResults } from "../slick-confirm-dialog/slick-confirm-dialog.module";
+import * as moment from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "../slick-confirm-dialog/slick-confirm-dialog.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+const excelExtensions = ['xls', 'xlt', 'xlm', 'xlsx', 'xlsm', 'xltx', 'xltm', 'xlsb', 'xla', 'xlam', 'xll', 'xlw'];
+const wordExtensions = ['doc', 'dot', 'wbk', 'docx', 'docm', 'dotx', 'dotm', 'docb'];
+const pdfExtensions = ['pdf'];
+export class SlickFileListItemComponent {
+    constructor() {
+        this.allowDelete = true;
+        this.showPhotoGallery = false;
+        this.showCheckbox = false;
+        this.confirmDelete = true;
+        this.fileChangeEmitter = new EventEmitter();
+        this.fileDeleteEmitter = new EventEmitter();
+        this.fileClicked = new EventEmitter();
+        this.checkChanged = new EventEmitter();
+        this.isEditing = false;
+        this.tempTitle = '';
+        this.fnDocumentClick = (e) => this.documentClick(e);
+        this.itemSize = 120;
+        this.itemImgSize = 90;
+        this.uuid = SlickUtilsService.newGuid();
+    }
+    ngOnChanges(changes) {
+        if (changes.thumbnailSize) {
+            this.itemImgSize = parseInt(this.thumbnailSize.toString());
+            this.itemSize = this.itemImgSize + 20;
+        }
+        if (changes.allowDelete && changes.allowDelete.currentValue)
+            this.allowDelete = (changes.allowDelete.currentValue.toString().toLowerCase() !== 'false');
+        if (changes.showPhotoGallery && changes.showPhotoGallery.currentValue)
+            this.showPhotoGallery = (changes.showPhotoGallery.currentValue.toString().toLowerCase() !== 'false');
+        if (changes.showCheckbox && changes.showCheckbox.currentValue)
+            this.showCheckbox = (changes.showCheckbox.currentValue.toString().toLowerCase() !== 'false');
+        this.confirmDelete = (this.confirmDelete.toString() === 'true') ? true : false;
+        if (this.file && this.file.name && !this.file.thumbnailBase64Image && !this.file.url) {
+            if (this.file.isChecked === null)
+                this.file.isChecked = false;
+            let fileNameParts = this.file.name.split('.');
+            if (fileNameParts.length > 1) {
+                let ext = fileNameParts[fileNameParts.length - 1].toLowerCase();
+                if (excelExtensions.indexOf(ext) >= 0) {
+                    this.file.thumbnailBase64Image = "data:image/png;base64,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";
+                }
+                else if (wordExtensions.indexOf(ext) >= 0) {
+                    this.file.thumbnailBase64Image = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADwAAAA7CAYAAAAn+enKAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAyZpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuNi1jMTM4IDc5LjE1OTgyNCwgMjAxNi8wOS8xNC0wMTowOTowMSAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENDIDIwMTcgKFdpbmRvd3MpIiB4bXBNTTpJbnN0YW5jZUlEPSJ4bXAuaWlkOkYzODkyMUVBODUwNzExRTc5MjkxQTlBRjg4QzFEQjY1IiB4bXBNTTpEb2N1bWVudElEPSJ4bXAuZGlkOkYzODkyMUVCODUwNzExRTc5MjkxQTlBRjg4QzFEQjY1Ij4gPHhtcE1NOkRlcml2ZWRGcm9tIHN0UmVmOmluc3RhbmNlSUQ9InhtcC5paWQ6RjM4OTIxRTg4NTA3MTFFNzkyOTFBOUFGODhDMURCNjUiIHN0UmVmOmRvY3VtZW50SUQ9InhtcC5kaWQ6RjM4OTIxRTk4NTA3MTFFNzkyOTFBOUFGODhDMURCNjUiLz4gPC9yZGY6RGVzY3JpcHRpb24+IDwvcmRmOlJERj4gPC94OnhtcG1ldGE+IDw/eHBhY2tldCBlbmQ9InIiPz4T4+oBAAAaRklEQVR42sxbaWxc13X+3jL7cBYON5GiNkqiVsuSvFSxHdtJnLhI0rRNkCaAu6AFArRFgiJG0RX90Q1ogC5IiwYpiqRNgLZpUjiF46y249i1LVubZUmWrIWkaJIiKYrkcDj7W/rdc99sJJ26sVH0AU+ct9+zfec7514ZxYUxxGwHE4UsxlbTuDAzDTsSxtYuYGK2iDM3ynjXFhMPHd6M752eTn7zuRsPrfjh99ZKK5+4PldKGoZfhefAAOB4HuD5CPkGfKjfgOEAvs8jv847fPiO+uPD8PVf33W5q3s99QJ1S3Dsyzs8z4XlmzBh8wGXp9ULuJm8ru7ht2AYvC6vl3GoY09+u4hEw3jPPVvxz5/7hRSvTNvYcOOnPAOxiI2+dBjjt1ZHP/3FU3/07RM3Pm76vj24KYldfXF8ZPsgPNPmXYYWgs9ZfDrCQ9v05ZwtkvHjvqfHCV8GpeXVg5aNfw0K7ymlyKOeFkgE57ESwqXIVIZ+DnLNcxvvD97jK+EpKg+rpoN/fOwcfnhiEpXVPKLJdJe9XlR5HP3ZGKbmVyIvnp/7/DPPj30qnovht352P37p3mHs25KAaUZk+P/ft7HJJZx+dRLT0zMYGU2jQ2ClJIOazKWiuPTG8t2f/cqpb1XKfs8f/9rtePTDo4hH4nLfcs3DcoHWcOpUqAfXM7Sign/EzZS9xZV9Oe/6jctapZ6nFdv6tq93dZd4dsM/fXm/R7eGWL31mNwtHuJ3vMfluTDd7J7RrLi2T28zDC2q3W5Zk8IO9STw1LnxR77wb69+dcv2Xvzgd+/B7k1ZVBg6V285qNZ97Z4csWEqQU3+9KC92pLReL6rAlG7JrSk6r6GexoisBawKWzTzb3WPa4+Z3jivwwf5bHa5T0eGworRBGm/k6gT4EAR3ufBe3iRuCMduODPIWhnI1nnp1+5AtfPvHVhx7YhW//wYO8wcTEzTqKDuPT9PgCX4OCvMBDYMsmWChrGL62stg9eHegIypVq1ddU4NXg3V9BMcIlKQFNgItyH3Bc17wvYaZGr/9tr9KHrsZbYYalniuCBwP8YdlYXOPjb9+cvzYn3zxla9+8MFd+NbvPygxenG2woESI00NFvADaOLoPQPBOW0xGIFb+tAC+nroRtNyysWN5qD8hm/7jXtbbqmOvUAIZWmBO+3tMPxWCAItL2nfXKdx7HWct1+fK2NzNoypciH5O//07L/s2p/B44Gwlyiscg/bUnHasCb/VTHrGzKoDrdUSGtopJQMFRzrOPZFy35w7Acu7Xv6nX7gDQiUqMJEvmhClKTjugnofM4LnkOnwEbwXa/T8k2BJ0opLDKgH/3y6c/BsLb94A8fFK8/N12WAVrqBa4XxKYRxI/THFwTgPyWO4o1m1Yw2s5rEzWArDEgt5GeVDyKVk2tUOZR9XKFDfq7ruRifZMpHuAFKawdeAW0mvJ3ZhL7A4eG8J1zs0defO76r3/u0fuwNZfC2HwNNbrEUMpEbxSoS8Dyo54lHzEsH2O3alit+YiHAyW4fhBTBur8HeP5zZmIKMltuj8xgMKMzVdQIgomoxZqvGYyQoa6o7wWEnHaEdtTpEYQluSDYVWquhibKiIaYpzahr5fuVEgtLKuy9+2p63RiN2mwOdvFfEXXzv9mb5tWTz6kb1Y5QsLVQ4gaePpyQpO3XSQDWsXVgp2+U+dpOnj+6IYTBqYKzh0ebOZhpT3xSMmlosu/v3ktNxrBcI6ri/x+MljOWzqjmBuuUahQ1gqVvAPz09KJgiZ2l3F4oE3NFhZuVLn/TYe+eAwVko6NZqh9pQY/FVprOnSnenPPnlmqu9HJ6d+/i9/4x6lQ0wuVhGy6khFQnh1wcNffbcAdBkNFJJ0g9k69uV68cidOcwsFSmQGiA/bGq8ziVCeOpSAX/2tWkgbAV+T8kdvmd2FffvjuJnjg0S/R30pCwU5138zdcnUCvVKLGhv6PCyA1iRVFO5UFTy3j/w8O4/TO34clXFuCapiCasqLrtqyoQqx53BnCsJ84PvuhdDrc9ci7t8mNVbpymCotkFzc0cvBdpuwbB9R+p0p3zZRTrp4fUlUyTRjBaRCmd8MUNQhupeBZAzJdJCnXUvyd7EcwvHxKgWuS5or1jXH7uqL0isMxK0AlWT3tKUEyV0UCzF8+APDMvDZpToScVMuGUaQ8xssVeLeDly6U2DzwvTCu+/Y1Y++TIKxVaIAzIsI0609bKNlN8cpSk2jniCjko6xc36hIgM1WXi4AbFQwloUaonufHaO1y1qXwoLX6BD4orufup6XjAhGdEOo9OUo2kCAcoiVigAM7hbvqXTWp03JmzccWAA84WaxgtPC6etaTQ910DAzBCw37aUZa6Uaz93eEdaDgo1YprQNw9lMpUBVky703wL41rnUE8/zKC8MutgpWKgi4OuO65OM/xyLGTh+mIdl2/WRDj5fKB++WzUxIWJMhZXHfSnbFZPhijZpEWMBiU1tGkatIJio1SsY+f2OEa3JTA+U0HEtvT7JNUZQQbQqc+kqxuNosUw0E4+zcXlMo6M9MhB3dH5T92sGFPCCmNvOgRUXFqH5x2dJmgCXF2qYr64ihTpteMami9z4HGi+titOpaWHYRtVcU1cpJiW1QIlTBNhB+/UUR/TwROnRaiFUvLVThzy1gplBkZjWTSqJz4D8Hx2IF+ZLtiWMzX+B2LQoMKDrG8DYmiVXUXIQZEaBDb0iI6rs4QDevbnlsnxFut5C2kM6B+vHOkW19zql6TQsbI28piRQ/v2xGhUHWtUQqlhDw7twLmNcTidps36ZRlWryhXMLZyVUc3dWNMgqwmAXec0cvyvWMjOHk5Tw5uyeIrSDaUvhQ9nHvbTl50xyVHQ1r5uW6FfEuR9FdaISvE+SiAVga5hriAb+Nr/hGEPSMR7pnoVbHnkxIrFahAFFb00SVLcvVOsZvMtr32ASyMj8WQoIAVql4eG2mLICmSYfmmWbATqyAfJweL+FXocE/TWv9+S+PYjAXxvdOzODpU/P8VghGwKMrdUpONnhsfxZnJ5ZxeTaPTCwSsLKAmTWYMwVXVo2GbDlnKwW3AZdtdLARo1V0+wqpgc0M7+1pHxfmPElbHLkepePg6pwSLIupfAE2EXYwG8eNBRfX5zmKqFKEq8FOKpsA9JRu6XpnxovCmpIJC1M3K7RaCfPLCTxxaklCKELSosLHpNIqdPc92xPYMZzAY8cXRAij4TVBlWF2cHFPZJJIcv2O1GS3l2kKlPSxvlhlbA6lQhihlS+Ms4igvyqUFhCiv52dLsugtw7EcGkqz9gs4cKsiakVF/GQGoQpA1G3m016yX/o6tfeKOIWSQ8dkABYQhehok7Cc3W6JCWVLx7h6vpotYQHbtuCBPP79VnFE+jkRH8JPy/Ah1YWFoJjB50QrHVp13PXVRp+QPSlRWOGsJusCG6ez7pN/qEQ+PKNCm4STB7Y3YPDg0kavY6nr5JsrJZh0gWlZvZa9N3wdRqJEFDmbpYEyUd6Y3i6toJozEah5GJ+sYJGbSf1kulKDn/gSA6LZFeLKzVk07bQxwYYNihlw3NdGkplNqNBLY22tGS23djoLzX5J19acx2M9lD9pI+e4zUJAbMCppfrmFioSiikSTJymZQyhri7L30lRf91mvOI8JIBpM/F95c9nLlcwgC9RzG1EFPJDYLRjcUiIgr5FH7yc7UKf2RtHB5N4fxkke+kMMwm1K2UgCpe1a74uiO7Ogfh81qczvJQ8fFmBDcsrQTW+ctHnui8g7VyLgGQ8tKlNfkIqxGtVnBxutJ8WalawclrROgIkZugZ6kOJlOEW3ZQr3m6qgniUmn9xNgCS3EL6YjF+0KYXCijWqojbOo6WnUva4tlHB5JYHgogwtX8vQOXR/TDpJGHRrBCZTZ2h3BD12iK281pZsjAis09nx/XWXR6IKUahaGGcd7U7zG5K8GoQiGoG7Vx8X5lsDnKPw4YyxGbzYdV1ozRVYi3aRUqQi/I/laCcLRRg2cvUKeXidtjVlkZ2VM3lzlMT1a2kOuJiJ04fcc6UeUIXRlukBlIBBGU1vlyp5Yde3eiKPO8tBUvGxtDDc4txJYuUoyFsK2PjKMSlXzVDfguBz3+FRL4FOXOeBCne7pBpzRRC3v4ZN3xnF4c5JsqUKru9pDmFauTJYxR4DrTtXx7MUJTC+swmA60cUD7yVHJnfFfbf3Y4axXSBeKAdVoSVCOggaDYYIWBNX1rtT94OS3WrPSgpE24rxNsGNoGOlmLVCuj19MbnP5MdMV/eQETMIPJVmnJy4UmyWdD6tWVcjovAfu7sb2wYTogxHVK9i1sMqLfrKWAEfu3cIt+/oxdQ8z4f8ZoekQEobzYZwdDSD8+OFoHHv6Hjl9/WufvOcNPRd4Q9u4OJN4Ou0sNdEOsNsqyAVJxWYY5FOXj3Sa3Mw1HBdu6qpnqN/XSfJWFzWOfXExJLkX9YMEuuVsnJnA3cfHMTuPr687IjFxFWluAZJxqzibnjo4ADKyyvqQYk7FecOQezIaBf6BsI4/to8wkyFqhmhqKzjBn8dZU3115fdbeyNBn0ToRsx7LXqqjWVlNyswrpI4NqSi6I/HUaJNauyrhIoxouL+QoWGctLK8ynb5QVXmlUVqYmn94/FJE371GVCK2t8qdqwQguEZnPXMtr77i4ACyVEbJNsaBkjJUq3n9sC4v9Mr757BVMzKzg1vIqqrUahdJNQZVWHdbaYlllcTl2dBu3gUttJjatYA5HC2i2NBE00FTqXyDlIohSaKLRak3iRQklMbbK1ETicH5yhYhaRVyhqyPdKFq0ikPbuuR9e/k30Z1Ajc9byjscMSyukVOrEV1RLsvB2a7O3VLe2XUcJMPq6crisx/di239FkFxEccvTePK1CzyK0Vy7rrCPSlABXNULLMCq9Xbsaklse23EQPdwNV5WvWtKo7Fgr1OT3QxmAhjK3PmC67Qs4DHelIknCX4KI2rzoQuIZW7GtKluGunFnj7QBQH+m28dIFkP2eKV4UIXDMsQl46O4erMwVVlUi+VgMqVon2uS7s36FnO37x4X145OEazo0t47kz8zh+bhZnr81SQJaxuTh6WLZFojHyg6B+DkiJ0SChgfC26kj6XmdytuhvRWqpRFetuX5A12ilARJrY05cRtWwoilywudOz6PGPIuEKZ1FJXO5QtfPRHFQam2FdmHsH+nCSy8vwejWLCxOD8mzKvqPZyaxSOZlqXzWqJ2XKzhwaBNGd/a25YwwbtvRJ/unPrwbJxkGT52ZwXH+PUGUt/0Q+vq7kOlKoN/oEnKkqmYFbI2Ma/uN+QyZavE1etYtFCpuoAhd5RQYu/fuSZAZ2ZgvOUjoOUN0qf7Va3mJu66EDdvRjVS/6GL/cBT7huJBa9XGT41m8SX/ujiAIXmWJSTLl399coYp3pVOpDTtZAKrirv2dkkXZF1jSlVsYVZPhwZlLzJdvnB+Ck+/PIsXzi3h5bPTiMVMfOPpLOWwkIzbzVC1DbfV4bYoMEOMud5rMn0FamWeU+3Y+/elsZm8epYxi6zuCyskr0lBYUp3UoGGNHvyVey7f4D5NtZMW4dGMjBSrKVduqvhSw4NkT8uEtzMwBoqJFzVFibaP3iot8mTTdNYx/f9oFpKRCN46I4R2fME0SdPTuH7Zybx1EtTOH55BZlQUvpnuh52vCbdJKuDahyaZtATDtoyqoe8qzcEMxTCvsEoTr5EUTO6caZsF1EDNIPmmRvMADo1HAniT5NXFwdGkoxlG2NvUGGpsJ70Vi8J60lwqa5oibLqWffEcPS2voD/rp+WFfq7Lq+wtk5H8dH37pS9VKpgz0gcp89cw62FPAYG67o8tILnlsqetEd0t1+nbBWPIap/EwmA2g7zBV9h8jP8iG6RSpPeg+60e+KqEvcs6u/cmW2jbSwZae39w1mMnV8GkrakJ8PzW22gxoTcqotDd/Ri29ZMZ/X2FjY9c+mLkuLxKD77iSPAJw6iWCxh/Pqk9hT1j+oDqjhUcaxhShYcoEL3zsYt9DAHq+32bSn6NwkArWA6uqnXAD5P9Z4ZlxXy4k19YdwxmmnL+fr5O3cxLqs13Udwdb85RMuGjMY0CyQc7tqf67DmW91U29g07bbJel96NLFYF4qrhUavTLdRO4sHvReqdQyp3nTgVvu2ZdCbNYRFGSr1KKoT0DqTDMdUbWaWjfuGE0gTpddudx3qkea8S0UqDmAGJW3DwHVhcAbefWjgHVkB0JiBmJ2dbQZXB39utEgklZJSqj6WmhZp3NrXE8f+zQkpDZm06JJ1Pasgu3YnMHcf3ZXacPbu8PYscv0xPl4jYlrr4rNIIOke7sJdR3PviMBGUC0tLS4ik8l0Cqwb4l7QufcIVnUMpCz0pkMIuJNsB5Vb5+u6D6y8QxakaDoonQgi7p2j2aDL0emOfQNJHFDPs/Jpv9QsYhZrOLSnC4N98XdIYA51ZYWyVLBpYGCDVSmSjvQSAkXZNnVHBcwNv3XrkT0pvaSBpKHBYb1gyVKZeS2eiRCRc9iQoHO7bU+3pIS1l0QBVPKx0d7m5Nw7sb3wygSWyR0i0egagf3G2gsScCdMImBgKGutXeKD2+iWoVQUVYIPXG1dQ4RnYUCGNMrad8+uzJsO4C51zTSlXWO07TXVtyFAvvvoAFoLHN7ephLGY09eQtQ02mI4mI4QYQ09L636zr3JEFKJaEvSwCQHmW629kZQY/lWYyqrKQrK6luVaVgu4+CudGNSBx1GCn4fPkjgSsexki9jterIhNoqOXl5yUHv1izuPpzriL+fCKyCDz93ehLPk30N5NKdoGU0pzZ80bzvV7EtZwW3GG0IzjRCFnRoVxKYq8ClCzp0T4e1bpVABpZyd+1NBd1Df0NaOLojiYMjfHehgrBaaacalSz5cItkhWkrk4k3u5w/6dYIh28+8zpu3sqzlt5g2ZIsJPFUaeUjHiE6ZyMbaE6vxPnb37sbv/0rh1j/hjTIydIFR5YLHdyZCRjSmig1dO/btkN44u/ez9rW4UBUV87UU6lUXn9/tJVO1LesDnCR8bWvynmzTadRFz86MY9UPK4nENoFbrkccyzdbCdTRywWkhl/y7DaErv+0CZWTmr/8QhpbEAMTPGa4cEs9ze3jOo85ot1Kt+TOYQsKWOY1Nb8X3j51TcWcXOxhP6uqF76tNbCjZU0CpEHuyMbQ+zb3PwNOqQbKckM2sSLrJoWl2qsyW8hlQxjIBvDUH8KoVDLCM1++hqPOj+2Ip1SvSDVWG9hpYQaU0yK1HFAzRyonp9hvKPC+v76ymdDimjZ6Oki8WEZGE+UMDFZx6uX8vjewiTLUAtbNqfIyzMY2cKMwfiUygktJdxYWMGpi/NIJyKEldUmlqxxaZ9Fv4c9m+k+tvmmgzZ+AiV4QUEiOZseZPP9ejEMGsvt9EIc029VQfyOahEnY2lsHUhhdGQVr4/H8OqFZfzndyfwBWaJvduT+NNPH2XRn25NpDFsvvP8jPTYEgzfpQW1vMJeL7DHD0So/c2p9e7cXDVn4G24ui8zEAWCU52xGQmZBD1TivWwTXJjWZ0LTtsKQOXigz1dst93ew2XJnrx+DM3yBdq9MjYmpBw8fjz00jFwgTCoqzVtu3IeoHLROfBpIn+rInWiseW9b2AmKjZ9XYre8EKyI0rVDRrWhW+0UhY0DzvVrCwxDzMUtBmKakWqPR0RZiSorSG1UyVfjDHBDNgYmpeiy58YNcQ9u0ckAXkMEJtTQJDemTPnZ7Bb350FGfP+Si6bU289jzs1ChwOkZN27I6rjN+fZmsqqh867ii8QgLi0QiHBQAxnolbUDkVfczFQojRsV2EYQKKw7mKfi1yRW8yoIiGYtIU26gJ4r+HKmgGQq6PLrbYLTBtJSClrUuzB7/r3Hcms1jz9ZunB3owuT0XGvJQ0MYVRrESCU35bR1zbUDV8sQ+TGbblghq1LrLFRnUaFlMhxCJm2xHIx32Nhv8w5jTSiEeCJDZal9gKxtaSWG6bkixmcreO7sDZmO6aG1t2yKYevmDAZ7kxTOXFPqoEWKAl2X6g6eeHEW4WQMO7d2EfRsyd2dFuaAmHrRTa13p3QpuBaYlCC2WizCuIjRLZOxCm4VDdyYL2Nypogq83UXraN6Xn0UoDuT6FjnqBefd1CDpkpCJCJ93WpPYv+Ig6nZJMZmVnDhWh4nX7sJ054iaCWxl7X43u0Unr9lrSW5u2nqiWBHpnAtPPX8OF65uERh09g2lJZyXS2zsFppSS9VUXX3QMYKBvI/pAwiaYJwnyDP7mNevEmXnJmr4fp0HpeuLki3Z6A3jhEObMdwGlmxfOfKe72sar37h2mRHVtyst99sIQrU8u4dG0Zpy8s4YcvT9ObTIzsSOPOfT14+F1bZB2mYogNRvYY0Vn16WyZLDBlxX7HemnhvGr1KR/YiEpunJp0elJxHGU8DvepHTiwPYWJOQ7weh4XL+dx/MQcUnT14U1J7NzSRaDJIZdO6KJgvcnbwsAPWsBxHBlV+yAePlbEuWvzOHHhJr7xgzdY0Bfx0/ftbCsILEzNL5NKvoF0LoF82ZOqD0YAdmabwFWaN0mBQ8nQWyyqjQ1zcSIZwf5kP/bv6MHM/jJeG1vExbEFXJxYwpnXb+H7L05h51AKRw9048DuTbLgbN27NyiilXK7swncf8d22T/wrmFEo3YbL9D3fenrr2HshVmgN6WmsoU+KwCWCrBhYdV4iwQfjtj2O0OpiJ6D/UnZ33dsy4b5+H+Ty9cq9+CuTRte+9BDu3H00FZ6HQULRdHbG2MJuhosQg9AK5FI4NmXLyKZMpkXK3q+6K2UZQbeknXCjBXLNJo0Qhbe8BOVip7n/bGsrW3t5MYfD3rgMGTWf3NfApsyESlLTauKx5+expXpZaRSsWZtbee6I4XPf+Vk6vN/f3wF9v/B/0N6q7T07bZ3giURiBADbu9X7WdVpBf+W4ABAJ2SzNRqphUQAAAAAElFTkSuQmCC";
+                }
+                else if (pdfExtensions.indexOf(ext) >= 0) {
+                    this.file.thumbnailBase64Image = "data:image/png;base64,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";
+                }
+                else {
+                    this.file.thumbnailBase64Image = "data:image/png;base64,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";
+                }
+            }
+        }
+        if (this.file && this.file.fileDate) {
+            const fileDateFormat = (this.file.fileDateFormat ?? '') !== '' ? this.file.fileDateFormat : 'M/D/YYYY h:mm:ss a';
+            this.fileDateFormatted = moment(this.file.fileDate).format(fileDateFormat);
+        }
+    }
+    onClick() {
+        if (this.fileClicked)
+            this.fileClicked.emit(this.file);
+    }
+    async deleteFile(e) {
+        e.stopPropagation();
+        e.preventDefault();
+        if (this.confirmDelete === false) {
+            this.fileDeleteEmitter.emit(this.file);
+        }
+        else {
+            const result = await this.deleteConfirmRef.confirm();
+            if (result === SlickConfirmDialogResults.Ok)
+                this.fileDeleteEmitter.emit(this.file);
+        }
+    }
+    async editTitle() {
+        this.isEditing = true;
+        this.tempTitle = this.file.title;
+        await SlickSleepService.sleep();
+        this.editTitleInputRef.nativeElement.setSelectionRange(0, this.editTitleInputRef.nativeElement.value.length);
+        this.editTitleInputRef.nativeElement.focus();
+        document.addEventListener("click", this.fnDocumentClick, true);
+    }
+    onKeyDown(e) {
+        if (e.which === 13) {
+            this.file.title = this.tempTitle;
+            this.fileChangeEmitter.emit(this.file);
+            this.isEditing = false;
+            document.removeEventListener("click", this.fnDocumentClick, true);
+        }
+        if (e.which === 27) {
+            this.tempTitle = null;
+            this.isEditing = false;
+            document.removeEventListener("click", this.fnDocumentClick, true);
+        }
+    }
+    async documentClick(e) {
+        await SlickSleepService.sleep();
+        const clickedInside = SlickUtilsService.checkParentClassExists(e.target, 'slick-file-list-item_title');
+        if (clickedInside)
+            return;
+        if (this.isEditing === true) {
+            this.file.title = this.tempTitle;
+            this.fileChangeEmitter.emit(this.file);
+            this.isEditing = false;
+            document.removeEventListener("click", this.fnDocumentClick, true);
+        }
+    }
+    async onCheckboxClicked(e) {
+        this.file.isChecked = !this.file.isChecked;
+        if (this.checkChanged)
+            this.checkChanged.emit(e);
+    }
+    ngOnDestroy() {
+        document.removeEventListener("click", this.fnDocumentClick, true);
+    }
+}
+/** @nocollapse */ SlickFileListItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickFileListItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ SlickFileListItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.3", type: SlickFileListItemComponent, selector: "slick-file-list-item", inputs: { file: "file", allowDelete: "allowDelete", showPhotoGallery: "showPhotoGallery", showCheckbox: "showCheckbox", thumbnailSize: "thumbnailSize", confirmDelete: "confirmDelete" }, outputs: { fileChangeEmitter: "fileChange", fileDeleteEmitter: "fileDelete", fileClicked: "fileClicked", checkChanged: "checkChanged" }, viewQueries: [{ propertyName: "titleDivRef", first: true, predicate: ["titleDivRef"], descendants: true }, { propertyName: "editTitleDivRef", first: true, predicate: ["editTitleDivRef"], descendants: true }, { propertyName: "editTitleInputRef", first: true, predicate: ["editTitleInputRef"], descendants: true }, { propertyName: "deleteConfirmRef", first: true, predicate: ["deleteConfirmRef"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div class=\"slick-file-list-item\" id=\"slick-file-list-item_{{uuid}}\">\r\n\t<div class=\"slick-file-list-item_img card\" (click)=\"onClick()\" [ngStyle]=\"{ 'cursor': (showPhotoGallery === true) ? 'pointer' : 'default' }\" [style.minHeight.px]=\"itemSize + 2\" [style.minWidth.px]=\"itemSize\">\r\n\t\t<img *ngIf=\"file.thumbnailBase64Image\" [src]=\"file.thumbnailBase64Image\" [style.maxWidth.px]=\"itemImgSize\" [style.maxHeight.px]=\"itemImgSize\" />\r\n\t\t<img *ngIf=\"!file.thumbnailBase64Image && file.base64Image\" [src]=\"file.base64Image\" [style.maxWidth.px]=\"itemImgSize\" [style.maxHeight.px]=\"itemImgSize\" />\r\n\t\t<img *ngIf=\"!file.thumbnailBase64Image && !file.base64Image && file.thumbnailUrl\" [src]=\"file.thumbnailUrl\" [style.maxWidth.px]=\"itemImgSize\" [style.maxHeight.px]=\"itemImgSize\" />\r\n\t\t<img *ngIf=\"!file.thumbnailBase64Image && !file.base64Image && !file.thumbnailUrl && file.url\" [src]=\"file.url\" [style.maxWidth.px]=\"itemImgSize\" [style.maxHeight.px]=\"itemImgSize\" />\r\n\t\t<i *ngIf=\"allowDelete\" class=\"fas fa-times-circle bg-white text-danger\" (click)=\"deleteFile($event)\"></i>\r\n\t</div>\r\n\t<div class=\"slick-file-list-item_title\" *ngIf=\"fileDateFormatted\" [style.minWidth.px]=\"itemSize\" [style.maxWidth.px]=\"itemSize\">\r\n\t\t<div class=\"slick-file-list-item_date\" *ngIf=\"fileDateFormatted\" [style.minWidth.px]=\"itemSize\">{{fileDateFormatted}}</div>\r\n\t</div>\r\n\t<div class=\"slick-file-list-item_title\" [style.minWidth.px]=\"itemSize\" [style.maxWidth.px]=\"itemSize\">\r\n\t\t<div class=\"slick-file-list-item_display-title\" #titleDivRef style=\"cursor: pointer\" *ngIf=\"!isEditing\" (click)=\"editTitle()\">{{file.title}}</div>\r\n\t\t<div #editTitleDivRef class=\"slick-file-list-item_edit-title\" *ngIf=\"isEditing\"><input #editTitleInputRef type=\"text\" class=\"form-control\" [(ngModel)]=\"tempTitle\" (keydown)=\"onKeyDown($event)\" [style.width.px]=\"itemSize\" /></div>\r\n\t</div>\r\n\r\n\t<!-- We want the user to be able to click just a little outside of the checkbox and still have it check -->\r\n\t<div *ngIf=\"showCheckbox === true\" class=\"slick-file-checkbox\" (click)=\"onCheckboxClicked($event)\">\r\n\t\t<input type=\"checkbox\" [ngModel]=\"file.isChecked\" />\r\n\t</div>\r\n</div>\r\n\r\n<slick-confirm-dialog #deleteConfirmRef>\r\n\t<h4 class=\"p-0 m-0 text-danger\">Are you sure you want to delete?</h4>\r\n</slick-confirm-dialog>", components: [{ type: i1.SlickConfirmDialogComponent, selector: "slick-confirm-dialog", inputs: ["width", "okButtonText", "cancelButtonText", "showOkButton", "showCancelButton"] }], directives: [{ type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { type: i3.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickFileListItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'slick-file-list-item', template: "<div class=\"slick-file-list-item\" id=\"slick-file-list-item_{{uuid}}\">\r\n\t<div class=\"slick-file-list-item_img card\" (click)=\"onClick()\" [ngStyle]=\"{ 'cursor': (showPhotoGallery === true) ? 'pointer' : 'default' }\" [style.minHeight.px]=\"itemSize + 2\" [style.minWidth.px]=\"itemSize\">\r\n\t\t<img *ngIf=\"file.thumbnailBase64Image\" [src]=\"file.thumbnailBase64Image\" [style.maxWidth.px]=\"itemImgSize\" [style.maxHeight.px]=\"itemImgSize\" />\r\n\t\t<img *ngIf=\"!file.thumbnailBase64Image && file.base64Image\" [src]=\"file.base64Image\" [style.maxWidth.px]=\"itemImgSize\" [style.maxHeight.px]=\"itemImgSize\" />\r\n\t\t<img *ngIf=\"!file.thumbnailBase64Image && !file.base64Image && file.thumbnailUrl\" [src]=\"file.thumbnailUrl\" [style.maxWidth.px]=\"itemImgSize\" [style.maxHeight.px]=\"itemImgSize\" />\r\n\t\t<img *ngIf=\"!file.thumbnailBase64Image && !file.base64Image && !file.thumbnailUrl && file.url\" [src]=\"file.url\" [style.maxWidth.px]=\"itemImgSize\" [style.maxHeight.px]=\"itemImgSize\" />\r\n\t\t<i *ngIf=\"allowDelete\" class=\"fas fa-times-circle bg-white text-danger\" (click)=\"deleteFile($event)\"></i>\r\n\t</div>\r\n\t<div class=\"slick-file-list-item_title\" *ngIf=\"fileDateFormatted\" [style.minWidth.px]=\"itemSize\" [style.maxWidth.px]=\"itemSize\">\r\n\t\t<div class=\"slick-file-list-item_date\" *ngIf=\"fileDateFormatted\" [style.minWidth.px]=\"itemSize\">{{fileDateFormatted}}</div>\r\n\t</div>\r\n\t<div class=\"slick-file-list-item_title\" [style.minWidth.px]=\"itemSize\" [style.maxWidth.px]=\"itemSize\">\r\n\t\t<div class=\"slick-file-list-item_display-title\" #titleDivRef style=\"cursor: pointer\" *ngIf=\"!isEditing\" (click)=\"editTitle()\">{{file.title}}</div>\r\n\t\t<div #editTitleDivRef class=\"slick-file-list-item_edit-title\" *ngIf=\"isEditing\"><input #editTitleInputRef type=\"text\" class=\"form-control\" [(ngModel)]=\"tempTitle\" (keydown)=\"onKeyDown($event)\" [style.width.px]=\"itemSize\" /></div>\r\n\t</div>\r\n\r\n\t<!-- We want the user to be able to click just a little outside of the checkbox and still have it check -->\r\n\t<div *ngIf=\"showCheckbox === true\" class=\"slick-file-checkbox\" (click)=\"onCheckboxClicked($event)\">\r\n\t\t<input type=\"checkbox\" [ngModel]=\"file.isChecked\" />\r\n\t</div>\r\n</div>\r\n\r\n<slick-confirm-dialog #deleteConfirmRef>\r\n\t<h4 class=\"p-0 m-0 text-danger\">Are you sure you want to delete?</h4>\r\n</slick-confirm-dialog>" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { file: [{
+                type: Input,
+                args: ["file"]
+            }], allowDelete: [{
+                type: Input,
+                args: ["allowDelete"]
+            }], showPhotoGallery: [{
+                type: Input,
+                args: ["showPhotoGallery"]
+            }], showCheckbox: [{
+                type: Input,
+                args: ["showCheckbox"]
+            }], thumbnailSize: [{
+                type: Input,
+                args: ["thumbnailSize"]
+            }], confirmDelete: [{
+                type: Input,
+                args: ["confirmDelete"]
+            }], fileChangeEmitter: [{
+                type: Output,
+                args: ["fileChange"]
+            }], fileDeleteEmitter: [{
+                type: Output,
+                args: ["fileDelete"]
+            }], fileClicked: [{
+                type: Output,
+                args: ["fileClicked"]
+            }], checkChanged: [{
+                type: Output,
+                args: ["checkChanged"]
+            }], titleDivRef: [{
+                type: ViewChild,
+                args: ["titleDivRef"]
+            }], editTitleDivRef: [{
+                type: ViewChild,
+                args: ["editTitleDivRef"]
+            }], editTitleInputRef: [{
+                type: ViewChild,
+                args: ["editTitleInputRef"]
+            }], deleteConfirmRef: [{
+                type: ViewChild,
+                args: ["deleteConfirmRef"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slick-file-list-item.component.js","sourceRoot":"","sources":["../../../../projects/components/src/slick-file-list/slick-file-list-item.component.ts","../../../../projects/components/src/slick-file-list/slick-file-list-item.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, ViewChild, EventEmitter, OnChanges, SimpleChanges, OnDestroy, ElementRef, HostBinding } from \"@angular/core\";\r\nimport { SlickSleepService } from \"../utils/slick-sleep.service\";\r\nimport { SlickUtilsService } from \"../utils/slick-utils.service\";\r\nimport { ISlickFileModel } from \"../slick-file-model/slick-file.model\";\r\nimport { SlickConfirmDialogComponent, SlickConfirmDialogResults } from \"../slick-confirm-dialog/slick-confirm-dialog.module\";\r\n\r\nimport * as moment from 'moment';\r\n\r\nconst excelExtensions: string[] = ['xls', 'xlt', 'xlm', 'xlsx', 'xlsm', 'xltx', 'xltm', 'xlsb', 'xla', 'xlam', 'xll', 'xlw'];\r\nconst wordExtensions: string[] = ['doc', 'dot', 'wbk', 'docx', 'docm', 'dotx', 'dotm', 'docb'];\r\nconst pdfExtensions: string[] = ['pdf'];\r\n\r\n@Component({\r\n\tselector: 'slick-file-list-item',\r\n\ttemplateUrl: 'slick-file-list-item.component.html'\r\n})\r\nexport class SlickFileListItemComponent implements OnChanges, OnDestroy {\r\n\t@Input(\"file\") file: ISlickFileModel;\t\r\n\t@Input(\"allowDelete\") allowDelete: boolean = true;\r\n\t@Input(\"showPhotoGallery\") showPhotoGallery: boolean = false;\r\n\t@Input(\"showCheckbox\") showCheckbox: boolean = false;\r\n\t@Input(\"thumbnailSize\") thumbnailSize: number;\r\n\t@Input(\"confirmDelete\") confirmDelete: boolean = true;\r\n\t@Output(\"fileChange\") fileChangeEmitter: EventEmitter<ISlickFileModel> = new EventEmitter();\r\n\t@Output(\"fileDelete\") fileDeleteEmitter: EventEmitter<ISlickFileModel> = new EventEmitter();\r\n\t@Output(\"fileClicked\") fileClicked: EventEmitter<ISlickFileModel> = new EventEmitter();\r\n\t@Output(\"checkChanged\") checkChanged: EventEmitter<MouseEvent> = new EventEmitter();\r\n\r\n\t@ViewChild(\"titleDivRef\") titleDivRef: ElementRef;\r\n\t@ViewChild(\"editTitleDivRef\") editTitleDivRef: ElementRef;\r\n\t@ViewChild(\"editTitleInputRef\") editTitleInputRef: ElementRef;\r\n\t@ViewChild(\"deleteConfirmRef\") deleteConfirmRef: SlickConfirmDialogComponent;\r\n\r\n\tuuid: string;\r\n\tisEditing: boolean = false;\r\n\ttempTitle: string = '';\r\n\tfileDateFormatted: string;\r\n\tfnDocumentClick = (e) => this.documentClick(e);\r\n\r\n\titemSize: number = 120;\r\n\titemImgSize: number = 90;\r\n\r\n\tconstructor() {\r\n\t\tthis.uuid = SlickUtilsService.newGuid();\r\n\t}\r\n\r\n\tngOnChanges(changes: SimpleChanges) {\r\n\t\tif (changes.thumbnailSize) {\r\n\t\t\tthis.itemImgSize = parseInt(this.thumbnailSize.toString());\r\n\t\t\tthis.itemSize = this.itemImgSize + 20;\r\n\t\t}\r\n\r\n\t\tif (changes.allowDelete && changes.allowDelete.currentValue)\r\n\t\t\tthis.allowDelete = (changes.allowDelete.currentValue.toString().toLowerCase() !== 'false');\t\t\r\n\r\n\t\tif (changes.showPhotoGallery && changes.showPhotoGallery.currentValue)\r\n\t\t\tthis.showPhotoGallery = (changes.showPhotoGallery.currentValue.toString().toLowerCase() !== 'false');\t\r\n\r\n\t\tif (changes.showCheckbox && changes.showCheckbox.currentValue)\r\n\t\t\tthis.showCheckbox = (changes.showCheckbox.currentValue.toString().toLowerCase() !== 'false');\r\n\r\n\t\tthis.confirmDelete = (this.confirmDelete.toString() === 'true') ? true : false;\r\n\r\n\t\tif (this.file && this.file.name && !this.file.thumbnailBase64Image && !this.file.url) {\r\n\t\t\tif (this.file.isChecked === null)\r\n\t\t\t\tthis.file.isChecked = false;\r\n\r\n\t\t\tlet fileNameParts = this.file.name.split('.');\r\n\t\t\tif (fileNameParts.length > 1) {\r\n\t\t\t\tlet ext = fileNameParts[fileNameParts.length - 1].toLowerCase();\r\n\r\n\t\t\t\tif (excelExtensions.indexOf(ext) >= 0) {\r\n\t\t\t\t\tthis.file.thumbnailBase64Image = \"data:image/png;base64,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\";\r\n\t\t\t\t}\r\n\t\t\t\telse if (wordExtensions.indexOf(ext) >= 0) {\r\n\t\t\t\t\tthis.file.thumbnailBase64Image = \"data:image/png;base64,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\";\r\n\t\t\t\t}\r\n\t\t\t\telse if (pdfExtensions.indexOf(ext) >= 0) {\r\n\t\t\t\t\tthis.file.thumbnailBase64Image = \"data:image/png;base64,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\";\r\n\t\t\t\t}\r\n\t\t\t\telse {\r\n\t\t\t\t\tthis.file.thumbnailBase64Image = \"data:image/png;base64,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\";\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tif (this.file && this.file.fileDate) {\r\n\t\t\tconst fileDateFormat = (this.file.fileDateFormat ?? '') !== '' ? this.file.fileDateFormat : 'M/D/YYYY h:mm:ss a';\r\n\t\t\tthis.fileDateFormatted = moment(this.file.fileDate).format(fileDateFormat);\r\n\t\t}\r\n\t}\r\n\r\n\tonClick() {\r\n\t\tif (this.fileClicked)\r\n\t\t\tthis.fileClicked.emit(this.file);\r\n\t}\r\n\r\n\tasync deleteFile(e: Event) {\r\n\t\te.stopPropagation();\r\n\t\te.preventDefault();\r\n\r\n\t\tif (this.confirmDelete === false) {\r\n\t\t\tthis.fileDeleteEmitter.emit(this.file);\r\n\t\t}\r\n\t\telse {\r\n\t\t\tconst result: SlickConfirmDialogResults = await this.deleteConfirmRef.confirm();\r\n\r\n\t\t\tif (result === SlickConfirmDialogResults.Ok)\r\n\t\t\t\tthis.fileDeleteEmitter.emit(this.file);\r\n\t\t}\r\n\t}\r\n\r\n\tasync editTitle() {\r\n\t\tthis.isEditing = true;\r\n\t\tthis.tempTitle = this.file.title;\r\n\t\tawait SlickSleepService.sleep();\r\n\t\tthis.editTitleInputRef.nativeElement.setSelectionRange(0, this.editTitleInputRef.nativeElement.value.length)\r\n\t\tthis.editTitleInputRef.nativeElement.focus();\r\n\t\tdocument.addEventListener(\"click\", this.fnDocumentClick, true);\r\n\t}\r\n\r\n\tonKeyDown(e: KeyboardEvent) {\r\n\t\tif (e.which === 13) {\r\n\t\t\tthis.file.title = this.tempTitle;\r\n\t\t\tthis.fileChangeEmitter.emit(this.file);\r\n\t\t\tthis.isEditing = false;\r\n\t\t\tdocument.removeEventListener(\"click\", this.fnDocumentClick, true);\r\n\t\t}\r\n\r\n\t\tif (e.which === 27) {\r\n\t\t\tthis.tempTitle = null;\r\n\t\t\tthis.isEditing = false;\r\n\t\t\tdocument.removeEventListener(\"click\", this.fnDocumentClick, true);\r\n\t\t}\r\n\t}\r\n\r\n\tasync documentClick(e: MouseEvent) {\r\n\t\tawait SlickSleepService.sleep();\r\n\t\tconst clickedInside = SlickUtilsService.checkParentClassExists(<HTMLElement>e.target, 'slick-file-list-item_title')\r\n\t\tif (clickedInside)\r\n\t\t\treturn;\r\n\r\n\t\tif (this.isEditing === true) {\r\n\t\t\tthis.file.title = this.tempTitle;\r\n\t\t\tthis.fileChangeEmitter.emit(this.file);\r\n\t\t\tthis.isEditing = false;\r\n\t\t\tdocument.removeEventListener(\"click\", this.fnDocumentClick, true);\r\n\t\t}\r\n\t}\r\n\r\n\tasync onCheckboxClicked(e: MouseEvent) {\r\n\t\tthis.file.isChecked = !this.file.isChecked;\r\n\t\tif (this.checkChanged)\r\n\t\t\tthis.checkChanged.emit(e);\r\n\t}\r\n\r\n\tngOnDestroy() {\r\n\t\tdocument.removeEventListener(\"click\", this.fnDocumentClick, true);\r\n\t}\r\n}\r\n","<div class=\"slick-file-list-item\" id=\"slick-file-list-item_{{uuid}}\">\r\n\t<div class=\"slick-file-list-item_img card\" (click)=\"onClick()\" [ngStyle]=\"{ 'cursor': (showPhotoGallery === true) ? 'pointer' : 'default' }\" [style.minHeight.px]=\"itemSize + 2\" [style.minWidth.px]=\"itemSize\">\r\n\t\t<img *ngIf=\"file.thumbnailBase64Image\" [src]=\"file.thumbnailBase64Image\" [style.maxWidth.px]=\"itemImgSize\" [style.maxHeight.px]=\"itemImgSize\" />\r\n\t\t<img *ngIf=\"!file.thumbnailBase64Image && file.base64Image\" [src]=\"file.base64Image\" [style.maxWidth.px]=\"itemImgSize\" [style.maxHeight.px]=\"itemImgSize\" />\r\n\t\t<img *ngIf=\"!file.thumbnailBase64Image && !file.base64Image && file.thumbnailUrl\" [src]=\"file.thumbnailUrl\" [style.maxWidth.px]=\"itemImgSize\" [style.maxHeight.px]=\"itemImgSize\" />\r\n\t\t<img *ngIf=\"!file.thumbnailBase64Image && !file.base64Image && !file.thumbnailUrl && file.url\" [src]=\"file.url\" [style.maxWidth.px]=\"itemImgSize\" [style.maxHeight.px]=\"itemImgSize\" />\r\n\t\t<i *ngIf=\"allowDelete\" class=\"fas fa-times-circle bg-white text-danger\" (click)=\"deleteFile($event)\"></i>\r\n\t</div>\r\n\t<div class=\"slick-file-list-item_title\" *ngIf=\"fileDateFormatted\" [style.minWidth.px]=\"itemSize\" [style.maxWidth.px]=\"itemSize\">\r\n\t\t<div class=\"slick-file-list-item_date\" *ngIf=\"fileDateFormatted\" [style.minWidth.px]=\"itemSize\">{{fileDateFormatted}}</div>\r\n\t</div>\r\n\t<div class=\"slick-file-list-item_title\" [style.minWidth.px]=\"itemSize\" [style.maxWidth.px]=\"itemSize\">\r\n\t\t<div class=\"slick-file-list-item_display-title\" #titleDivRef style=\"cursor: pointer\" *ngIf=\"!isEditing\" (click)=\"editTitle()\">{{file.title}}</div>\r\n\t\t<div #editTitleDivRef class=\"slick-file-list-item_edit-title\" *ngIf=\"isEditing\"><input #editTitleInputRef type=\"text\" class=\"form-control\" [(ngModel)]=\"tempTitle\" (keydown)=\"onKeyDown($event)\" [style.width.px]=\"itemSize\" /></div>\r\n\t</div>\r\n\r\n\t<!-- We want the user to be able to click just a little outside of the checkbox and still have it check -->\r\n\t<div *ngIf=\"showCheckbox === true\" class=\"slick-file-checkbox\" (click)=\"onCheckboxClicked($event)\">\r\n\t\t<input type=\"checkbox\" [ngModel]=\"file.isChecked\" />\r\n\t</div>\r\n</div>\r\n\r\n<slick-confirm-dialog #deleteConfirmRef>\r\n\t<h4 class=\"p-0 m-0 text-danger\">Are you sure you want to delete?</h4>\r\n</slick-confirm-dialog>"]}