@ecodev/natural 41.3.0 → 42.2.0

package/esm2020/lib/modules/file/abstract-file.mjs

@@ -0,0 +1,231 @@
+import { Directive, EventEmitter, HostListener, Inject, Input, Output, } from '@angular/core';
+import { acceptType, createInvisibleFileInputWrap, detectSwipe, eventToFiles, fileListToArray, isFileInput, stopEvent, } from './utils';
+import { NaturalAbstractController } from '../../classes/abstract-controller';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "./file.service";
+/**
+ * A master base set of logic intended to support file select/drag/drop operations
+ *
+ * In most cases you probably want click-to-select and drag-to-select, so you should use:
+ *
+ *     <div naturalFileDrop [selectable]="true"></div>
+ *
+ * @dynamic
+ */
+export class NaturalAbstractFile extends NaturalAbstractController {
+    constructor(element, naturalFileService, document) {
+        super();
+        this.element = element;
+        this.naturalFileService = naturalFileService;
+        this.document = document;
+        this.validators = [
+            { name: 'accept', fn: this.acceptValidator },
+            { name: 'fileSize', fn: this.fileSizeValidator },
+        ];
+        /**
+         * Whether we should accept a single file or multiple files
+         */
+        this.multiple = false;
+        /**
+         * Comma-separated list of unique file type specifiers. Like the native element
+         * it can be a mixed of mime-type and file extensions.
+         *
+         * See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file#accept
+         */
+        this.accept = '';
+        /**
+         * Maximum file size in bytes. 0 means no validation at all.
+         */
+        this.maxSize = 0;
+        /**
+         * Disable the file selection entirely
+         */
+        this.fileSelectionDisabled = false;
+        /**
+         * Whether the user can click on the element to select something
+         *
+         * This has only effect during initialization. Subsequent changes will have
+         * no effect.
+         */
+        this.selectable = false;
+        /**
+         * If true, the file selection will be broadcast through `NaturalFileService.filesChanged`.
+         *
+         * It is useful to set this to false if there is two upload on a page with different purpose
+         * and the second upload should not be confused with the first one.
+         */
+        this.broadcast = true;
+        /**
+         * The single valid file that has been selected.
+         *
+         * It is for convenience of use, and will only emit if there is at least one
+         * valid file. See `filesChange` for a more complete output.
+         */
+        this.fileChange = new EventEmitter();
+        /**
+         * The list of files that have been selected.
+         */
+        this.filesChange = new EventEmitter();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        delete this.fileElement; // faster memory release of dom element
+    }
+    ngOnInit() {
+        if (this.selectable) {
+            this.enableSelecting();
+        }
+        this.getFileElement().multiple = this.multiple;
+    }
+    ngOnChanges(changes) {
+        if (changes.accept) {
+            this.getFileElement().setAttribute('accept', changes.accept.currentValue || '*');
+        }
+    }
+    getFileElement() {
+        if (this.fileElement) {
+            return this.fileElement;
+        }
+        // elm is a file input
+        if (isFileInput(this.element.nativeElement)) {
+            this.fileElement = this.element.nativeElement;
+            return this.fileElement;
+        }
+        // create foo file input
+        const label = createInvisibleFileInputWrap(this.document);
+        this.fileElement = label.getElementsByTagName('input')[0];
+        this.fileElement.addEventListener('change', this.changeFn.bind(this));
+        this.element.nativeElement.appendChild(label);
+        return this.fileElement;
+    }
+    enableSelecting() {
+        const elm = this.element.nativeElement;
+        if (isFileInput(elm)) {
+            const bindedHandler = () => this.beforeSelect();
+            elm.addEventListener('click', bindedHandler);
+            elm.addEventListener('touchstart', bindedHandler);
+            return;
+        }
+        else {
+            const bindedHandler = (event) => this.clickHandler(event);
+            elm.addEventListener('click', bindedHandler);
+            elm.addEventListener('touchstart', bindedHandler);
+            elm.addEventListener('touchend', bindedHandler);
+        }
+    }
+    handleFiles(files) {
+        const selection = {
+            valid: [],
+            invalid: [],
+        };
+        for (const file of files) {
+            const error = this.validate(file);
+            if (error) {
+                selection.invalid.push({
+                    file: file,
+                    error: error,
+                });
+            }
+            else {
+                selection.valid.push(file);
+            }
+        }
+        if (selection.valid.length) {
+            this.fileChange.emit(selection.valid[0]);
+        }
+        if (selection.valid.length || selection.invalid.length) {
+            this.filesChange.emit(selection);
+            if (this.broadcast) {
+                this.naturalFileService.filesChanged.next(selection);
+            }
+        }
+        this.getFileElement().value = '';
+    }
+    /**
+     * Called when input has files
+     */
+    changeFn(event) {
+        if (!(event.target instanceof HTMLInputElement)) {
+            return;
+        }
+        const fileList = event.target.files;
+        if (!fileList) {
+            return;
+        }
+        stopEvent(event);
+        this.handleFiles(fileListToArray(fileList));
+    }
+    clickHandler(event) {
+        const elm = this.element.nativeElement;
+        if (elm.getAttribute('disabled') || this.fileSelectionDisabled) {
+            return false;
+        }
+        // prevent the click if it is a swipe
+        if (detectSwipe(event)) {
+            return true;
+        }
+        const fileElm = this.getFileElement();
+        fileElm.click();
+        this.beforeSelect();
+        return false;
+    }
+    beforeSelect() {
+        if (!this.fileElement) {
+            return;
+        }
+        // if no files in array, be sure browser doesnt prevent reselect of same file (see github issue 27)
+        this.fileElement.value = '';
+    }
+    onChange(event) {
+        const fileList = this.getFileElement().files;
+        const files = fileList ? fileListToArray(fileList) : eventToFiles(event);
+        if (!files.length) {
+            return;
+        }
+        stopEvent(event);
+        this.handleFiles(files);
+    }
+    validate(file) {
+        for (const validator of this.validators) {
+            if (!validator.fn.call(this, file)) {
+                return validator.name;
+            }
+        }
+        return null;
+    }
+    acceptValidator(item) {
+        return acceptType(this.accept, item.type, item.name);
+    }
+    fileSizeValidator(item) {
+        return !(this.maxSize && item.size > this.maxSize);
+    }
+}
+NaturalAbstractFile.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalAbstractFile, deps: [{ token: i0.ElementRef }, { token: i1.NaturalFileService }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive });
+NaturalAbstractFile.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: NaturalAbstractFile, inputs: { multiple: "multiple", accept: "accept", maxSize: "maxSize", fileSelectionDisabled: "fileSelectionDisabled", selectable: "selectable", broadcast: "broadcast" }, outputs: { fileChange: "fileChange", filesChange: "filesChange" }, host: { listeners: { "change": "onChange($event)" } }, usesInheritance: true, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalAbstractFile, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.NaturalFileService }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; }, propDecorators: { multiple: [{
+                type: Input
+            }], accept: [{
+                type: Input
+            }], maxSize: [{
+                type: Input
+            }], fileSelectionDisabled: [{
+                type: Input
+            }], selectable: [{
+                type: Input
+            }], broadcast: [{
+                type: Input
+            }], fileChange: [{
+                type: Output
+            }], filesChange: [{
+                type: Output
+            }], onChange: [{
+                type: HostListener,
+                args: ['change', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-file.js","sourceRoot":"","sources":["../../../../../../projects/natural/src/lib/modules/file/abstract-file.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Directive,\n    ElementRef,\n    EventEmitter,\n    HostListener,\n    Inject,\n    Input,\n    OnChanges,\n    OnDestroy,\n    OnInit,\n    Output,\n    SimpleChanges,\n} from '@angular/core';\nimport {\n    acceptType,\n    createInvisibleFileInputWrap,\n    detectSwipe,\n    eventToFiles,\n    fileListToArray,\n    isFileInput,\n    stopEvent,\n} from './utils';\nimport {NaturalFileService} from './file.service';\nimport {NaturalAbstractController} from '../../classes/abstract-controller';\nimport {DOCUMENT} from '@angular/common';\n\nexport interface InvalidFile {\n    file: File;\n    error: string;\n}\n\nexport interface FileSelection {\n    /**\n     * The list of files that have been selected.\n     */\n    valid: File[];\n\n    /**\n     * The list of files that have been selected but are invalid according to validators.\n     */\n    invalid: InvalidFile[];\n}\n\n/**\n * A master base set of logic intended to support file select/drag/drop operations\n *\n * In most cases you probably want click-to-select and drag-to-select, so you should use:\n *\n *     <div naturalFileDrop [selectable]=\"true\"></div>\n *\n * @dynamic\n */\n@Directive()\nexport abstract class NaturalAbstractFile extends NaturalAbstractController implements OnInit, OnDestroy, OnChanges {\n    private fileElement?: HTMLInputElement;\n    private readonly validators = [\n        {name: 'accept', fn: this.acceptValidator},\n        {name: 'fileSize', fn: this.fileSizeValidator},\n    ];\n\n    /**\n     * Whether we should accept a single file or multiple files\n     */\n    @Input() public multiple = false;\n\n    /**\n     * Comma-separated list of unique file type specifiers. Like the native element\n     * it can be a mixed of mime-type and file extensions.\n     *\n     * See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file#accept\n     */\n    @Input() public accept = '';\n\n    /**\n     * Maximum file size in bytes. 0 means no validation at all.\n     */\n    @Input() public maxSize = 0;\n\n    /**\n     * Disable the file selection entirely\n     */\n    @Input() public fileSelectionDisabled = false;\n\n    /**\n     * Whether the user can click on the element to select something\n     *\n     * This has only effect during initialization. Subsequent changes will have\n     * no effect.\n     */\n    @Input() public selectable = false;\n\n    /**\n     * If true, the file selection will be broadcast through `NaturalFileService.filesChanged`.\n     *\n     * It is useful to set this to false if there is two upload on a page with different purpose\n     * and the second upload should not be confused with the first one.\n     */\n    @Input() public broadcast = true;\n\n    /**\n     * The single valid file that has been selected.\n     *\n     * It is for convenience of use, and will only emit if there is at least one\n     * valid file. See `filesChange` for a more complete output.\n     */\n    @Output() public readonly fileChange = new EventEmitter<File>();\n\n    /**\n     * The list of files that have been selected.\n     */\n    @Output() public readonly filesChange = new EventEmitter<FileSelection>();\n\n    public constructor(\n        private readonly element: ElementRef<HTMLElement>,\n        protected readonly naturalFileService: NaturalFileService,\n        @Inject(DOCUMENT) private readonly document: Document,\n    ) {\n        super();\n    }\n\n    public ngOnDestroy(): void {\n        super.ngOnDestroy();\n        delete this.fileElement; // faster memory release of dom element\n    }\n\n    public ngOnInit(): void {\n        if (this.selectable) {\n            this.enableSelecting();\n        }\n\n        this.getFileElement().multiple = this.multiple;\n    }\n\n    public ngOnChanges(changes: SimpleChanges): void {\n        if (changes.accept) {\n            this.getFileElement().setAttribute('accept', changes.accept.currentValue || '*');\n        }\n    }\n\n    private getFileElement(): HTMLInputElement {\n        if (this.fileElement) {\n            return this.fileElement;\n        }\n\n        // elm is a file input\n        if (isFileInput(this.element.nativeElement)) {\n            this.fileElement = this.element.nativeElement;\n\n            return this.fileElement;\n        }\n\n        // create foo file input\n        const label = createInvisibleFileInputWrap(this.document);\n        this.fileElement = label.getElementsByTagName('input')[0];\n        this.fileElement.addEventListener('change', this.changeFn.bind(this));\n        this.element.nativeElement.appendChild(label);\n\n        return this.fileElement;\n    }\n\n    private enableSelecting(): void {\n        const elm = this.element.nativeElement;\n\n        if (isFileInput(elm)) {\n            const bindedHandler = (): void => this.beforeSelect();\n            elm.addEventListener('click', bindedHandler);\n            elm.addEventListener('touchstart', bindedHandler);\n            return;\n        } else {\n            const bindedHandler = (event: Event): boolean => this.clickHandler(event);\n            elm.addEventListener('click', bindedHandler);\n            elm.addEventListener('touchstart', bindedHandler);\n            elm.addEventListener('touchend', bindedHandler);\n        }\n    }\n\n    protected handleFiles(files: File[]): void {\n        const selection: FileSelection = {\n            valid: [],\n            invalid: [],\n        };\n\n        for (const file of files) {\n            const error = this.validate(file);\n            if (error) {\n                selection.invalid.push({\n                    file: file,\n                    error: error,\n                });\n            } else {\n                selection.valid.push(file);\n            }\n        }\n\n        if (selection.valid.length) {\n            this.fileChange.emit(selection.valid[0]);\n        }\n\n        if (selection.valid.length || selection.invalid.length) {\n            this.filesChange.emit(selection);\n\n            if (this.broadcast) {\n                this.naturalFileService.filesChanged.next(selection);\n            }\n        }\n\n        this.getFileElement().value = '';\n    }\n\n    /**\n     * Called when input has files\n     */\n    private changeFn(event: Event): void {\n        if (!(event.target instanceof HTMLInputElement)) {\n            return;\n        }\n\n        const fileList = event.target.files;\n\n        if (!fileList) {\n            return;\n        }\n\n        stopEvent(event);\n        this.handleFiles(fileListToArray(fileList));\n    }\n\n    private clickHandler(event: Event): boolean {\n        const elm = this.element.nativeElement;\n        if (elm.getAttribute('disabled') || this.fileSelectionDisabled) {\n            return false;\n        }\n\n        // prevent the click if it is a swipe\n        if (detectSwipe(event)) {\n            return true;\n        }\n\n        const fileElm = this.getFileElement();\n        fileElm.click();\n        this.beforeSelect();\n\n        return false;\n    }\n\n    private beforeSelect(): void {\n        if (!this.fileElement) {\n            return;\n        }\n\n        // if no files in array, be sure browser doesnt prevent reselect of same file (see github issue 27)\n        this.fileElement.value = '';\n    }\n\n    @HostListener('change', ['$event'])\n    public onChange(event: Event): void {\n        const fileList = this.getFileElement().files;\n        const files: File[] = fileList ? fileListToArray(fileList) : eventToFiles(event);\n\n        if (!files.length) {\n            return;\n        }\n\n        stopEvent(event);\n        this.handleFiles(files);\n    }\n\n    private validate(file: File): string | null {\n        for (const validator of this.validators) {\n            if (!validator.fn.call(this, file)) {\n                return validator.name;\n            }\n        }\n\n        return null;\n    }\n\n    private acceptValidator(item: File): boolean {\n        return acceptType(this.accept, item.type, item.name);\n    }\n\n    private fileSizeValidator(item: File): boolean {\n        return !(this.maxSize && item.size > this.maxSize);\n    }\n}\n"]}

package/esm2020/lib/modules/file/component/file.component.mjs

@@ -0,0 +1,143 @@
+import { Component, EventEmitter, HostBinding, Inject, Input, Output, } from '@angular/core';
+import { of, Subject } from 'rxjs';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "../file.service";
+import * as i2 from "@angular/platform-browser";
+import * as i3 from "../../icon/icon.component";
+import * as i4 from "../file-drop.directive";
+import * as i5 from "@angular/material/core";
+import * as i6 from "@angular/common";
+import * as i7 from "../../common/pipes/capitalize.pipe";
+// @dynamic
+export class FileComponent {
+    constructor(naturalFileService, sanitizer, document) {
+        this.naturalFileService = naturalFileService;
+        this.sanitizer = sanitizer;
+        this.document = document;
+        this.height = 250;
+        this.action = null;
+        this.backgroundSize = 'contain';
+        /**
+         * Comma separated list of accepted mimetypes
+         */
+        this.accept = 'image/bmp,image/gif,image/jpeg,image/pjpeg,image/png,image/svg+xml,image/svg,image/webp';
+        this.model = null;
+        /**
+         * If provided, get updated on change
+         * Is not used for reading -> use [model]
+         */
+        this.formCtrl = null;
+        this.modelChange = new EventEmitter();
+        this.imagePreview = null;
+        this.filePreview = null;
+    }
+    ngOnInit() {
+        this.updateImage();
+    }
+    ngOnChanges(changes) {
+        if (changes.model && changes.model.previousValue !== changes.model.currentValue) {
+            this.updateImage();
+        }
+    }
+    upload(file) {
+        this.model = { file: file };
+        this.updateImage();
+        if (this.formCtrl) {
+            this.formCtrl.setValue(this.model);
+        }
+        if (this.service) {
+            this.service.create(this.model).subscribe(result => {
+                this.model = result;
+                this.modelChange.emit(result);
+            });
+        }
+        else {
+            this.modelChange.emit(this.model);
+        }
+    }
+    getDownloadLink() {
+        if (this.action !== 'download') {
+            return null;
+        }
+        return this.naturalFileService.getDownloadLink(this.model);
+    }
+    updateImage() {
+        this.imagePreview = null;
+        this.filePreview = null;
+        if (!this.model) {
+            return;
+        }
+        if (this.model.file?.type.includes('image/')) {
+            // Model from upload (before saving)
+            this.getBase64(this.model.file).subscribe(result => {
+                const content = 'url(data:' + this.model?.file?.type + ';base64,' + result + ')';
+                this.imagePreview = this.sanitizer.bypassSecurityTrustStyle(content);
+            });
+        }
+        else if (this.model.file) {
+            this.filePreview = this.model.file.type.split('/')[1];
+        }
+        else if (this.model.__typename === 'Image' && this.model.id) {
+            // Model image with id, use specific API to render image by size
+            const window = this.document.defaultView;
+            if (!window) {
+                throw new Error('Could not show image preview because `window` is undefined');
+            }
+            const loc = window.location;
+            const height = this.height ? '/' + this.height : '';
+            // create image url without port to stay compatible with dev mode
+            const image = loc.protocol + '//' + loc.hostname + '/api/image/' + this.model.id + height;
+            this.imagePreview = this.sanitizer.bypassSecurityTrustStyle('url(' + image + ')');
+        }
+        else if (this.model?.mime && ['File', 'AccountingDocument'].includes(this.model.__typename || '')) {
+            this.filePreview = this.model.mime.split('/')[1];
+        }
+        else if (this.model.src) {
+            // external url
+            this.imagePreview = this.sanitizer.bypassSecurityTrustStyle('url(' + this.model.src + ')');
+        }
+    }
+    getBase64(file) {
+        if (!file) {
+            return of('');
+        }
+        const subject = new Subject();
+        const reader = new FileReader();
+        reader.addEventListener('load', (ev) => {
+            subject.next(btoa(ev.target.result));
+            subject.complete();
+        });
+        reader.readAsBinaryString(file);
+        return subject.asObservable();
+    }
+}
+FileComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: FileComponent, deps: [{ token: i1.NaturalFileService }, { token: i2.DomSanitizer }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });
+FileComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.0", type: FileComponent, selector: "natural-file", inputs: { height: "height", action: "action", backgroundSize: "backgroundSize", accept: "accept", service: "service", model: "model", formCtrl: "formCtrl" }, outputs: { modelChange: "modelChange" }, host: { properties: { "style.height.px": "this.height" } }, usesOnChanges: true, ngImport: i0, template: "<a\n    (fileChange)=\"upload($event)\"\n    naturalFileDrop\n    [selectable]=\"true\"\n    [accept]=\"accept\"\n    [attr.href]=\"getDownloadLink()\"\n    [class.has-action]=\"!!action\"\n    [class.suggest-upload]=\"!model && action === 'upload'\"\n    [fileSelectionDisabled]=\"action !== 'upload'\"\n    [matRippleDisabled]=\"!action\"\n    [style.backgroundImage]=\"imagePreview\"\n    [style.backgroundSize]=\"backgroundSize\"\n    matRipple\n    target=\"_blank\"\n>\n    <div *ngIf=\"filePreview\" class=\"file-preview\">\n        <natural-icon [size]=\"height * 0.33\" name=\"attachment\"></natural-icon>\n        {{ filePreview | uppercase }}\n    </div>\n\n    <div class=\"action-overlay\">\n        <natural-icon *ngIf=\"action === 'upload'\" [size]=\"height * 0.66\" name=\"cloud_upload\"></natural-icon>\n        <natural-icon *ngIf=\"action === 'download'\" [size]=\"height * 0.66\" name=\"get_app\"></natural-icon>\n        {{ action | capitalize }}\n    </div>\n</a>\n", styles: [":host{display:flex;flex-direction:row;overflow:hidden;position:relative}:host>a{position:relative;flex:1;background-position:center;background-repeat:no-repeat}:host>a.has-action{cursor:pointer}:host>a.has-action.suggest-upload .action-overlay{opacity:.66}:host>a.has-action:hover .action-overlay,:host>a.has-action.natural-file-over .action-overlay{opacity:1}:host .action-overlay,:host .file-preview{display:flex;flex-direction:column;position:absolute;top:0;left:0;right:0;bottom:0;justify-content:center;align-items:center;font-size:36px;line-height:1.3em;text-align:center}:host .action-overlay{opacity:0}:host .action-overlay>div{opacity:0;position:absolute;top:0;left:0;right:0;bottom:0;display:flex;justify-content:center;align-items:center}\n"], components: [{ type: i3.NaturalIconComponent, selector: "natural-icon", inputs: ["label", "labelColor", "labelPosition", "name", "size"] }], directives: [{ type: i4.NaturalFileDropDirective, selector: ":not([naturalFileSelect])[naturalFileDrop]", outputs: ["fileOver"] }, { type: i5.MatRipple, selector: "[mat-ripple], [matRipple]", inputs: ["matRippleColor", "matRippleUnbounded", "matRippleCentered", "matRippleRadius", "matRippleAnimation", "matRippleDisabled", "matRippleTrigger"], exportAs: ["matRipple"] }, { type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "uppercase": i6.UpperCasePipe, "capitalize": i7.NaturalCapitalizePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: FileComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'natural-file', template: "<a\n    (fileChange)=\"upload($event)\"\n    naturalFileDrop\n    [selectable]=\"true\"\n    [accept]=\"accept\"\n    [attr.href]=\"getDownloadLink()\"\n    [class.has-action]=\"!!action\"\n    [class.suggest-upload]=\"!model && action === 'upload'\"\n    [fileSelectionDisabled]=\"action !== 'upload'\"\n    [matRippleDisabled]=\"!action\"\n    [style.backgroundImage]=\"imagePreview\"\n    [style.backgroundSize]=\"backgroundSize\"\n    matRipple\n    target=\"_blank\"\n>\n    <div *ngIf=\"filePreview\" class=\"file-preview\">\n        <natural-icon [size]=\"height * 0.33\" name=\"attachment\"></natural-icon>\n        {{ filePreview | uppercase }}\n    </div>\n\n    <div class=\"action-overlay\">\n        <natural-icon *ngIf=\"action === 'upload'\" [size]=\"height * 0.66\" name=\"cloud_upload\"></natural-icon>\n        <natural-icon *ngIf=\"action === 'download'\" [size]=\"height * 0.66\" name=\"get_app\"></natural-icon>\n        {{ action | capitalize }}\n    </div>\n</a>\n", styles: [":host{display:flex;flex-direction:row;overflow:hidden;position:relative}:host>a{position:relative;flex:1;background-position:center;background-repeat:no-repeat}:host>a.has-action{cursor:pointer}:host>a.has-action.suggest-upload .action-overlay{opacity:.66}:host>a.has-action:hover .action-overlay,:host>a.has-action.natural-file-over .action-overlay{opacity:1}:host .action-overlay,:host .file-preview{display:flex;flex-direction:column;position:absolute;top:0;left:0;right:0;bottom:0;justify-content:center;align-items:center;font-size:36px;line-height:1.3em;text-align:center}:host .action-overlay{opacity:0}:host .action-overlay>div{opacity:0;position:absolute;top:0;left:0;right:0;bottom:0;display:flex;justify-content:center;align-items:center}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.NaturalFileService }, { type: i2.DomSanitizer }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; }, propDecorators: { height: [{
+                type: HostBinding,
+                args: ['style.height.px']
+            }, {
+                type: Input
+            }], action: [{
+                type: Input
+            }], backgroundSize: [{
+                type: Input
+            }], accept: [{
+                type: Input
+            }], service: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }], formCtrl: [{
+                type: Input
+            }], modelChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file.component.js","sourceRoot":"","sources":["../../../../../../../projects/natural/src/lib/modules/file/component/file.component.ts","../../../../../../../projects/natural/src/lib/modules/file/component/file.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    EventEmitter,\n    HostBinding,\n    Inject,\n    Input,\n    OnChanges,\n    OnInit,\n    Output,\n    SimpleChanges,\n} from '@angular/core';\nimport {AbstractControl} from '@angular/forms';\nimport {DomSanitizer, SafeStyle} from '@angular/platform-browser';\nimport {Observable, of, Subject} from 'rxjs';\nimport {NaturalFileService} from '../file.service';\nimport {NaturalAbstractModelService} from '../../../services/abstract-model.service';\nimport {DOCUMENT} from '@angular/common';\nimport {FileModel} from '../types';\n\n// @dynamic\n@Component({\n    selector: 'natural-file',\n    templateUrl: './file.component.html',\n    styleUrls: ['./file.component.scss'],\n})\nexport class FileComponent<\n    TService extends NaturalAbstractModelService<any, any, any, any, FileModel, any, any, any, any, any>,\n> implements OnInit, OnChanges\n{\n    @HostBinding('style.height.px') @Input() public height = 250;\n\n    @Input() public action: 'upload' | 'download' | null = null;\n\n    @Input() public backgroundSize = 'contain';\n\n    /**\n     * Comma separated list of accepted mimetypes\n     */\n    @Input() public accept = 'image/bmp,image/gif,image/jpeg,image/pjpeg,image/png,image/svg+xml,image/svg,image/webp';\n\n    @Input() public service?: TService;\n\n    @Input() public model: FileModel | null = null;\n\n    /**\n     * If provided, get updated on change\n     * Is not used for reading -> use [model]\n     */\n    @Input() public formCtrl: AbstractControl | null | undefined = null;\n\n    @Output() public readonly modelChange = new EventEmitter<FileModel>();\n\n    public imagePreview: SafeStyle | null = null;\n    public filePreview: string | null = null;\n\n    public constructor(\n        private readonly naturalFileService: NaturalFileService,\n        private readonly sanitizer: DomSanitizer,\n        @Inject(DOCUMENT) private readonly document: Document,\n    ) {}\n\n    public ngOnInit(): void {\n        this.updateImage();\n    }\n\n    public ngOnChanges(changes: SimpleChanges): void {\n        if (changes.model && changes.model.previousValue !== changes.model.currentValue) {\n            this.updateImage();\n        }\n    }\n\n    public upload(file: File): void {\n        this.model = {file: file};\n        this.updateImage();\n\n        if (this.formCtrl) {\n            this.formCtrl.setValue(this.model);\n        }\n\n        if (this.service) {\n            this.service.create(this.model).subscribe(result => {\n                this.model = result;\n                this.modelChange.emit(result);\n            });\n        } else {\n            this.modelChange.emit(this.model);\n        }\n    }\n\n    public getDownloadLink(): null | string {\n        if (this.action !== 'download') {\n            return null;\n        }\n\n        return this.naturalFileService.getDownloadLink(this.model);\n    }\n\n    private updateImage(): void {\n        this.imagePreview = null;\n        this.filePreview = null;\n        if (!this.model) {\n            return;\n        }\n\n        if (this.model.file?.type.includes('image/')) {\n            // Model from upload (before saving)\n            this.getBase64(this.model.file).subscribe(result => {\n                const content = 'url(data:' + this.model?.file?.type + ';base64,' + result + ')';\n                this.imagePreview = this.sanitizer.bypassSecurityTrustStyle(content);\n            });\n        } else if (this.model.file) {\n            this.filePreview = this.model.file.type.split('/')[1];\n        } else if (this.model.__typename === 'Image' && this.model.id) {\n            // Model image with id, use specific API to render image by size\n            const window = this.document.defaultView;\n            if (!window) {\n                throw new Error('Could not show image preview because `window` is undefined');\n            }\n\n            const loc = window.location;\n            const height = this.height ? '/' + this.height : '';\n\n            // create image url without port to stay compatible with dev mode\n            const image = loc.protocol + '//' + loc.hostname + '/api/image/' + this.model.id + height;\n            this.imagePreview = this.sanitizer.bypassSecurityTrustStyle('url(' + image + ')');\n        } else if (this.model?.mime && ['File', 'AccountingDocument'].includes(this.model.__typename || '')) {\n            this.filePreview = this.model.mime.split('/')[1];\n        } else if (this.model.src) {\n            // external url\n            this.imagePreview = this.sanitizer.bypassSecurityTrustStyle('url(' + this.model.src + ')');\n        }\n    }\n\n    private getBase64(file: File | null): Observable<string> {\n        if (!file) {\n            return of('');\n        }\n\n        const subject = new Subject<string>();\n\n        const reader = new FileReader();\n        reader.addEventListener('load', (ev: any) => {\n            subject.next(btoa(ev.target.result));\n            subject.complete();\n        });\n        reader.readAsBinaryString(file);\n\n        return subject.asObservable();\n    }\n}\n","<a\n    (fileChange)=\"upload($event)\"\n    naturalFileDrop\n    [selectable]=\"true\"\n    [accept]=\"accept\"\n    [attr.href]=\"getDownloadLink()\"\n    [class.has-action]=\"!!action\"\n    [class.suggest-upload]=\"!model && action === 'upload'\"\n    [fileSelectionDisabled]=\"action !== 'upload'\"\n    [matRippleDisabled]=\"!action\"\n    [style.backgroundImage]=\"imagePreview\"\n    [style.backgroundSize]=\"backgroundSize\"\n    matRipple\n    target=\"_blank\"\n>\n    <div *ngIf=\"filePreview\" class=\"file-preview\">\n        <natural-icon [size]=\"height * 0.33\" name=\"attachment\"></natural-icon>\n        {{ filePreview | uppercase }}\n    </div>\n\n    <div class=\"action-overlay\">\n        <natural-icon *ngIf=\"action === 'upload'\" [size]=\"height * 0.66\" name=\"cloud_upload\"></natural-icon>\n        <natural-icon *ngIf=\"action === 'download'\" [size]=\"height * 0.66\" name=\"get_app\"></natural-icon>\n        {{ action | capitalize }}\n    </div>\n</a>\n"]}

package/esm2020/lib/modules/file/file-drop.directive.mjs

@@ -0,0 +1,110 @@
+import { Directive, EventEmitter, HostBinding, HostListener, Output } from '@angular/core';
+import { NaturalAbstractFile } from './abstract-file';
+import { eventToFiles, stopEvent } from './utils';
+import { asyncScheduler, Subject } from 'rxjs';
+import { takeUntil, throttleTime } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+/**
+ * This directive has all options to select files, and adds support for drag'n'drop.
+ *
+ * It will add the CSS class `natural-file-over` on the component when a file is
+ * dragged over. It is up to the component to have some specific styling by using
+ * this class.
+ *
+ * In most cases you probably also want click-to-select, so you should use:
+ *
+ *     <div naturalFileDrop [selectable]="true"></div>
+ *
+ */
+export class NaturalFileDropDirective extends NaturalAbstractFile {
+    constructor() {
+        super(...arguments);
+        this.fileOverClass = false;
+        /**
+         * Emits whenever files are being dragged over
+         */
+        this.fileOver = new EventEmitter();
+        this.rawFileOver = new Subject();
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        // Automatically change the class, but not too often to avoid visual
+        // flickering in Chrome when hovering across child HTML element of our host.
+        // It's not absolutely perfect and if dragging slowly and precisely we can
+        // still see flicker, but it should be better for most normal usages.
+        this.rawFileOver
+            .pipe(takeUntil(this.ngUnsubscribe), throttleTime(200, asyncScheduler, {
+            leading: true,
+            trailing: true,
+        }))
+            .subscribe(fileOver => {
+            this.fileOver.emit(fileOver);
+            this.fileOverClass = fileOver;
+        });
+    }
+    onDrop(event) {
+        if (this.fileSelectionDisabled) {
+            return;
+        }
+        this.closeDrags();
+        const files = eventToFiles(event);
+        if (!files.length) {
+            return;
+        }
+        stopEvent(event);
+        this.handleFiles(files);
+    }
+    onDragOver(event) {
+        if (!this.hasObservers()) {
+            return;
+        }
+        if (this.fileSelectionDisabled) {
+            return;
+        }
+        stopEvent(event);
+        // Change cursor
+        const transfer = event.dataTransfer;
+        if (transfer) {
+            transfer.dropEffect = 'copy';
+        }
+        this.rawFileOver.next(true);
+    }
+    closeDrags() {
+        this.rawFileOver.next(false);
+    }
+    onDragLeave(event) {
+        if (this.fileSelectionDisabled) {
+            return;
+        }
+        stopEvent(event);
+        this.closeDrags();
+    }
+    hasObservers() {
+        return (this.fileChange.observed ||
+            this.filesChange.observed ||
+            (this.broadcast && this.naturalFileService.filesChanged.observed));
+    }
+}
+NaturalFileDropDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalFileDropDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+NaturalFileDropDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: NaturalFileDropDirective, selector: ":not([naturalFileSelect])[naturalFileDrop]", outputs: { fileOver: "fileOver" }, host: { listeners: { "drop": "onDrop($event)", "dragover": "onDragOver($event)", "dragleave": "onDragLeave($event)" }, properties: { "class.natural-file-over": "this.fileOverClass" } }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalFileDropDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: ':not([naturalFileSelect])[naturalFileDrop]',
+                }]
+        }], propDecorators: { fileOverClass: [{
+                type: HostBinding,
+                args: ['class.natural-file-over']
+            }], fileOver: [{
+                type: Output
+            }], onDrop: [{
+                type: HostListener,
+                args: ['drop', ['$event']]
+            }], onDragOver: [{
+                type: HostListener,
+                args: ['dragover', ['$event']]
+            }], onDragLeave: [{
+                type: HostListener,
+                args: ['dragleave', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/file/file-select.directive.mjs

@@ -0,0 +1,28 @@
+import { Directive, Input } from '@angular/core';
+import { NaturalAbstractFile } from './abstract-file';
+import * as i0 from "@angular/core";
+/**
+ * This directive has all options to select files, except drag'n'drop.
+ */
+export class NaturalFileSelectDirective extends NaturalAbstractFile {
+    constructor() {
+        super(...arguments);
+        /**
+         * Whether the user can click on the element to select something
+         *
+         * Override parent to enable it by default
+         */
+        this.selectable = true;
+    }
+}
+NaturalFileSelectDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalFileSelectDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+NaturalFileSelectDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: NaturalFileSelectDirective, selector: ":not([naturalFileDrop])[naturalFileSelect]", inputs: { selectable: "selectable" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalFileSelectDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: ':not([naturalFileDrop])[naturalFileSelect]',
+                }]
+        }], propDecorators: { selectable: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1zZWxlY3QuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmF0dXJhbC9zcmMvbGliL21vZHVsZXMvZmlsZS9maWxlLXNlbGVjdC5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBRSxLQUFLLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDL0MsT0FBTyxFQUFDLG1CQUFtQixFQUFDLE1BQU0saUJBQWlCLENBQUM7O0FBRXBEOztHQUVHO0FBSUgsTUFBTSxPQUFPLDBCQUEyQixTQUFRLG1CQUFtQjtJQUhuRTs7UUFJSTs7OztXQUlHO1FBQ2EsZUFBVSxHQUFHLElBQUksQ0FBQztLQUNyQzs7dUhBUFksMEJBQTBCOzJHQUExQiwwQkFBMEI7MkZBQTFCLDBCQUEwQjtrQkFIdEMsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsNENBQTRDO2lCQUN6RDs4QkFPbUIsVUFBVTtzQkFBekIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RGlyZWN0aXZlLCBJbnB1dH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge05hdHVyYWxBYnN0cmFjdEZpbGV9IGZyb20gJy4vYWJzdHJhY3QtZmlsZSc7XG5cbi8qKlxuICogVGhpcyBkaXJlY3RpdmUgaGFzIGFsbCBvcHRpb25zIHRvIHNlbGVjdCBmaWxlcywgZXhjZXB0IGRyYWcnbidkcm9wLlxuICovXG5ARGlyZWN0aXZlKHtcbiAgICBzZWxlY3RvcjogJzpub3QoW25hdHVyYWxGaWxlRHJvcF0pW25hdHVyYWxGaWxlU2VsZWN0XScsXG59KVxuZXhwb3J0IGNsYXNzIE5hdHVyYWxGaWxlU2VsZWN0RGlyZWN0aXZlIGV4dGVuZHMgTmF0dXJhbEFic3RyYWN0RmlsZSB7XG4gICAgLyoqXG4gICAgICogV2hldGhlciB0aGUgdXNlciBjYW4gY2xpY2sgb24gdGhlIGVsZW1lbnQgdG8gc2VsZWN0IHNvbWV0aGluZ1xuICAgICAqXG4gICAgICogT3ZlcnJpZGUgcGFyZW50IHRvIGVuYWJsZSBpdCBieSBkZWZhdWx0XG4gICAgICovXG4gICAgQElucHV0KCkgcHVibGljIHNlbGVjdGFibGUgPSB0cnVlO1xufVxuIl19

package/esm2020/lib/modules/file/file.module.mjs

@@ -0,0 +1,24 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { NaturalFileDropDirective } from './file-drop.directive';
+import { NaturalFileSelectDirective } from './file-select.directive';
+import { FileComponent } from './component/file.component';
+import { NaturalIconModule } from '../icon/icon.module';
+import { MatRippleModule } from '@angular/material/core';
+import { NaturalCommonModule } from '../common/common-module';
+import * as i0 from "@angular/core";
+const declarations = [NaturalFileDropDirective, NaturalFileSelectDirective, FileComponent];
+export class NaturalFileModule {
+}
+NaturalFileModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalFileModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NaturalFileModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalFileModule, declarations: [NaturalFileDropDirective, NaturalFileSelectDirective, FileComponent], imports: [CommonModule, NaturalIconModule, MatRippleModule, NaturalCommonModule], exports: [NaturalFileDropDirective, NaturalFileSelectDirective, FileComponent] });
+NaturalFileModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalFileModule, imports: [[CommonModule, NaturalIconModule, MatRippleModule, NaturalCommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalFileModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, NaturalIconModule, MatRippleModule, NaturalCommonModule],
+                    declarations: declarations,
+                    exports: declarations,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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