@sumaris-net/ngx-components 2.6.4-alpha5 → 2.6.4-alpha6

package/esm2020/src/app/shared/directives/drag-and-drop.directive.mjs

@@ -0,0 +1,53 @@
+import { Directive, EventEmitter, HostBinding, HostListener, Output } from '@angular/core';
+import { isNotEmptyArray } from '../functions';
+import * as i0 from "@angular/core";
+export class DragAndDropDirective {
+    constructor() {
+        this.fileDropped = new EventEmitter();
+    }
+    // Dragover listener
+    onDragOver(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.fileOver = true;
+    }
+    // Dragleave listener
+    onDragLeave(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.fileOver = false;
+    }
+    // Drop listener
+    ondrop(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.fileOver = false;
+        const files = event.dataTransfer?.files;
+        if (isNotEmptyArray(files)) {
+            this.fileDropped.emit(files);
+        }
+    }
+}
+DragAndDropDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DragAndDropDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+DragAndDropDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: DragAndDropDirective, selector: "[appDragAndDrop]", outputs: { fileDropped: "fileDropped" }, host: { listeners: { "dragover": "onDragOver($event)", "dragleave": "onDragLeave($event)", "drop": "ondrop($event)" }, properties: { "class.fileover": "this.fileOver" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DragAndDropDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[appDragAndDrop]',
+                }]
+        }], propDecorators: { fileOver: [{
+                type: HostBinding,
+                args: ['class.fileover']
+            }], fileDropped: [{
+                type: Output
+            }], onDragOver: [{
+                type: HostListener,
+                args: ['dragover', ['$event']]
+            }], onDragLeave: [{
+                type: HostListener,
+                args: ['dragleave', ['$event']]
+            }], ondrop: [{
+                type: HostListener,
+                args: ['drop', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/app/shared/directives/ng-var.directive.mjs

@@ -0,0 +1,31 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NgVarDirective {
+    constructor(templateRef, vcRef) {
+        this.templateRef = templateRef;
+        this.vcRef = vcRef;
+        this.context = {
+            $implicit: null,
+            ngVar: null,
+        };
+        this.hasView = false;
+    }
+    set ngVar(context) {
+        this.context.$implicit = this.context.ngVar = context;
+        if (!this.hasView) {
+            this.vcRef.createEmbeddedView(this.templateRef, this.context);
+            this.hasView = true;
+        }
+    }
+}
+NgVarDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgVarDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+NgVarDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: NgVarDirective, selector: "[ngVar]", inputs: { ngVar: "ngVar" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: NgVarDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ngVar]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }]; }, propDecorators: { ngVar: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctdmFyLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvc2hhcmVkL2RpcmVjdGl2ZXMvbmctdmFyLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsU0FBUyxFQUFFLEtBQUssRUFBZ0MsTUFBTSxlQUFlLENBQUM7O0FBSzlFLE1BQU0sT0FBTyxjQUFjO0lBc0J6QixZQUNVLFdBQTZCLEVBQzdCLEtBQXVCO1FBRHZCLGdCQUFXLEdBQVgsV0FBVyxDQUFrQjtRQUM3QixVQUFLLEdBQUwsS0FBSyxDQUFrQjtRQVp6QixZQUFPLEdBR1g7WUFDRixTQUFTLEVBQUUsSUFBSTtZQUNmLEtBQUssRUFBRSxJQUFJO1NBQ1osQ0FBQztRQUVNLFlBQU8sR0FBWSxLQUFLLENBQUM7SUFLOUIsQ0FBQztJQXZCSixJQUNJLEtBQUssQ0FBQyxPQUFnQjtRQUN4QixJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssR0FBRyxPQUFPLENBQUM7UUFFdEQsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUU7WUFDakIsSUFBSSxDQUFDLEtBQUssQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsV0FBVyxFQUFFLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUM5RCxJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQztTQUNyQjtJQUNILENBQUM7OzJHQVZVLGNBQWM7K0ZBQWQsY0FBYzsyRkFBZCxjQUFjO2tCQUgxQixTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxTQUFTO2lCQUNwQjtpSUFJSyxLQUFLO3NCQURSLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0RpcmVjdGl2ZSwgSW5wdXQsIFRlbXBsYXRlUmVmLCBWaWV3Q29udGFpbmVyUmVmfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW25nVmFyXScsXG59KVxuZXhwb3J0IGNsYXNzIE5nVmFyRGlyZWN0aXZlIHtcblxuICBASW5wdXQoKVxuICBzZXQgbmdWYXIoY29udGV4dDogdW5rbm93bikge1xuICAgIHRoaXMuY29udGV4dC4kaW1wbGljaXQgPSB0aGlzLmNvbnRleHQubmdWYXIgPSBjb250ZXh0O1xuXG4gICAgaWYgKCF0aGlzLmhhc1ZpZXcpIHtcbiAgICAgIHRoaXMudmNSZWYuY3JlYXRlRW1iZWRkZWRWaWV3KHRoaXMudGVtcGxhdGVSZWYsIHRoaXMuY29udGV4dCk7XG4gICAgICB0aGlzLmhhc1ZpZXcgPSB0cnVlO1xuICAgIH1cbiAgfVxuXG4gIHByaXZhdGUgY29udGV4dDoge1xuICAgICRpbXBsaWNpdDogdW5rbm93bjtcbiAgICBuZ1ZhcjogdW5rbm93bjtcbiAgfSA9IHtcbiAgICAkaW1wbGljaXQ6IG51bGwsXG4gICAgbmdWYXI6IG51bGwsXG4gIH07XG5cbiAgcHJpdmF0ZSBoYXNWaWV3OiBib29sZWFuID0gZmFsc2U7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHJpdmF0ZSB0ZW1wbGF0ZVJlZjogVGVtcGxhdGVSZWY8YW55PixcbiAgICBwcml2YXRlIHZjUmVmOiBWaWV3Q29udGFpbmVyUmVmXG4gICkge31cbn1cbiJdfQ==

package/esm2020/src/app/shared/directives/resizable/resizable.component.mjs

@@ -0,0 +1,59 @@
+import { Component, EventEmitter, HostBinding, Input, Optional, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/table";
+import * as i2 from "./resizable.directive";
+export class ResizableComponent {
+    constructor(columnDef) {
+        this.columnDef = columnDef;
+        this.sizeChanged = new EventEmitter();
+        this.width = null;
+        this.minWidth = null;
+        this.maxWidth = null;
+        this.debug = false;
+    }
+    onResize(width, opts) {
+        if (!this.resizable)
+            return;
+        if (this.debug)
+            console.info(`resize:${width}`);
+        this.minWidth = width + 'px';
+        this.maxWidth = width + 'px';
+        if (!opts || opts.emitEvent) {
+            this.sizeChanged.emit(width);
+        }
+    }
+    onFit(opts) {
+        if (!this.resizable)
+            return;
+        if (this.debug)
+            console.info('fit');
+        this.width = 'auto';
+        this.minWidth = null;
+        this.maxWidth = null;
+        if (!opts || opts.emitEvent) {
+            this.sizeChanged.emit(undefined);
+        }
+    }
+}
+ResizableComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ResizableComponent, deps: [{ token: i1.MatColumnDef, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+ResizableComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: ResizableComponent, selector: "th[resizable]", inputs: { resizable: "resizable" }, outputs: { sizeChanged: "sizeChanged" }, host: { properties: { "style.width": "this.width", "style.min-width": "this.minWidth", "style.max-width": "this.maxWidth" } }, ngImport: i0, template: "<div class=\"wrapper\">\n  <div class=\"content\">\n    <ng-content></ng-content>\n  </div>\n  <div class=\"bar\" [class.cdk-visually-hidden]=\"!resizable\" (resizable)=\"onResize($event)\" (fit)=\"onFit()\"></div>\n</div>\n", styles: [":host:last-child .bar{display:none}.wrapper{display:flex;justify-content:flex-end;align-items:center}.content{flex:1}.bar{height:var(--app-table-header-height, 55px);width:10px;justify-self:flex-end;border-left:4px solid transparent;border-right:4px solid transparent;background:var(--ion-color-secondary);background-clip:content-box;cursor:ew-resize;opacity:0;transition:opacity .3s}.bar:hover,.bar:active{opacity:1}:host-context(.mat-table-sticky) .bar{width:12px!important}\n"], dependencies: [{ kind: "directive", type: i2.ResizableDirective, selector: "[resizable]", outputs: ["resizable", "fit"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ResizableComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'th[resizable]', template: "<div class=\"wrapper\">\n  <div class=\"content\">\n    <ng-content></ng-content>\n  </div>\n  <div class=\"bar\" [class.cdk-visually-hidden]=\"!resizable\" (resizable)=\"onResize($event)\" (fit)=\"onFit()\"></div>\n</div>\n", styles: [":host:last-child .bar{display:none}.wrapper{display:flex;justify-content:flex-end;align-items:center}.content{flex:1}.bar{height:var(--app-table-header-height, 55px);width:10px;justify-self:flex-end;border-left:4px solid transparent;border-right:4px solid transparent;background:var(--ion-color-secondary);background-clip:content-box;cursor:ew-resize;opacity:0;transition:opacity .3s}.bar:hover,.bar:active{opacity:1}:host-context(.mat-table-sticky) .bar{width:12px!important}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.MatColumnDef, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { resizable: [{
+                type: Input
+            }], sizeChanged: [{
+                type: Output
+            }], width: [{
+                type: HostBinding,
+                args: ['style.width']
+            }], minWidth: [{
+                type: HostBinding,
+                args: ['style.min-width']
+            }], maxWidth: [{
+                type: HostBinding,
+                args: ['style.max-width']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzaXphYmxlLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvc2hhcmVkL2RpcmVjdGl2ZXMvcmVzaXphYmxlL3Jlc2l6YWJsZS5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL3NoYXJlZC9kaXJlY3RpdmVzL3Jlc2l6YWJsZS9yZXNpemFibGUudGVtcGxhdGUuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxXQUFXLEVBQUUsS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7Ozs7QUFTOUYsTUFBTSxPQUFPLGtCQUFrQjtJQWU3QixZQUF3QyxTQUF1QjtRQUF2QixjQUFTLEdBQVQsU0FBUyxDQUFjO1FBYnJELGdCQUFXLEdBQUcsSUFBSSxZQUFZLEVBQVUsQ0FBQztRQUduRCxVQUFLLEdBQWtCLElBQUksQ0FBQztRQUc1QixhQUFRLEdBQWtCLElBQUksQ0FBQztRQUcvQixhQUFRLEdBQWtCLElBQUksQ0FBQztRQUV2QixVQUFLLEdBQUcsS0FBSyxDQUFDO0lBRTRDLENBQUM7SUFFbkUsUUFBUSxDQUFDLEtBQWEsRUFBRSxJQUE2QjtRQUNuRCxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVM7WUFBRSxPQUFPO1FBQzVCLElBQUksSUFBSSxDQUFDLEtBQUs7WUFBRSxPQUFPLENBQUMsSUFBSSxDQUFDLFVBQVUsS0FBSyxFQUFFLENBQUMsQ0FBQztRQUNoRCxJQUFJLENBQUMsUUFBUSxHQUFHLEtBQUssR0FBRyxJQUFJLENBQUM7UUFDN0IsSUFBSSxDQUFDLFFBQVEsR0FBRyxLQUFLLEdBQUcsSUFBSSxDQUFDO1FBQzdCLElBQUksQ0FBQyxJQUFJLElBQUksSUFBSSxDQUFDLFNBQVMsRUFBRTtZQUMzQixJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztTQUM5QjtJQUNILENBQUM7SUFFRCxLQUFLLENBQUMsSUFBNkI7UUFDakMsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTO1lBQUUsT0FBTztRQUM1QixJQUFJLElBQUksQ0FBQyxLQUFLO1lBQUUsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNwQyxJQUFJLENBQUMsS0FBSyxHQUFHLE1BQU0sQ0FBQztRQUNwQixJQUFJLENBQUMsUUFBUSxHQUFHLElBQUksQ0FBQztRQUNyQixJQUFJLENBQUMsUUFBUSxHQUFHLElBQUksQ0FBQztRQUNyQixJQUFJLENBQUMsSUFBSSxJQUFJLElBQUksQ0FBQyxTQUFTLEVBQUU7WUFDM0IsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7U0FDbEM7SUFDSCxDQUFDOzsrR0FwQ1Usa0JBQWtCO21HQUFsQixrQkFBa0IsaVFDVC9CLGtPQU1BOzJGREdhLGtCQUFrQjtrQkFOOUIsU0FBUzsrQkFFRSxlQUFlOzswQkFtQlosUUFBUTs0Q0FkWixTQUFTO3NCQUFqQixLQUFLO2dCQUNJLFdBQVc7c0JBQXBCLE1BQU07Z0JBR1AsS0FBSztzQkFESixXQUFXO3VCQUFDLGFBQWE7Z0JBSTFCLFFBQVE7c0JBRFAsV0FBVzt1QkFBQyxpQkFBaUI7Z0JBSTlCLFFBQVE7c0JBRFAsV0FBVzt1QkFBQyxpQkFBaUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIEV2ZW50RW1pdHRlciwgSG9zdEJpbmRpbmcsIElucHV0LCBPcHRpb25hbCwgT3V0cHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBNYXRDb2x1bW5EZWYgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC90YWJsZSc7XG5cbkBDb21wb25lbnQoe1xuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQGFuZ3VsYXItZXNsaW50L2NvbXBvbmVudC1zZWxlY3RvclxuICBzZWxlY3RvcjogJ3RoW3Jlc2l6YWJsZV0nLFxuICB0ZW1wbGF0ZVVybDogJy4vcmVzaXphYmxlLnRlbXBsYXRlLmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi9yZXNpemFibGUuc3R5bGUuc2NzcyddLFxufSlcbmV4cG9ydCBjbGFzcyBSZXNpemFibGVDb21wb25lbnQge1xuICBASW5wdXQoKSByZXNpemFibGU6IGJvb2xlYW47XG4gIEBPdXRwdXQoKSBzaXplQ2hhbmdlZCA9IG5ldyBFdmVudEVtaXR0ZXI8bnVtYmVyPigpO1xuXG4gIEBIb3N0QmluZGluZygnc3R5bGUud2lkdGgnKVxuICB3aWR0aDogc3RyaW5nIHwgbnVsbCA9IG51bGw7XG5cbiAgQEhvc3RCaW5kaW5nKCdzdHlsZS5taW4td2lkdGgnKVxuICBtaW5XaWR0aDogc3RyaW5nIHwgbnVsbCA9IG51bGw7XG5cbiAgQEhvc3RCaW5kaW5nKCdzdHlsZS5tYXgtd2lkdGgnKVxuICBtYXhXaWR0aDogc3RyaW5nIHwgbnVsbCA9IG51bGw7XG5cbiAgcHJpdmF0ZSBkZWJ1ZyA9IGZhbHNlO1xuXG4gIGNvbnN0cnVjdG9yKEBPcHRpb25hbCgpIHB1YmxpYyByZWFkb25seSBjb2x1bW5EZWY6IE1hdENvbHVtbkRlZikge31cblxuICBvblJlc2l6ZSh3aWR0aDogbnVtYmVyLCBvcHRzPzogeyBlbWl0RXZlbnQ6IGJvb2xlYW4gfSkge1xuICAgIGlmICghdGhpcy5yZXNpemFibGUpIHJldHVybjtcbiAgICBpZiAodGhpcy5kZWJ1ZykgY29uc29sZS5pbmZvKGByZXNpemU6JHt3aWR0aH1gKTtcbiAgICB0aGlzLm1pbldpZHRoID0gd2lkdGggKyAncHgnO1xuICAgIHRoaXMubWF4V2lkdGggPSB3aWR0aCArICdweCc7XG4gICAgaWYgKCFvcHRzIHx8IG9wdHMuZW1pdEV2ZW50KSB7XG4gICAgICB0aGlzLnNpemVDaGFuZ2VkLmVtaXQod2lkdGgpO1xuICAgIH1cbiAgfVxuXG4gIG9uRml0KG9wdHM/OiB7IGVtaXRFdmVudDogYm9vbGVhbiB9KSB7XG4gICAgaWYgKCF0aGlzLnJlc2l6YWJsZSkgcmV0dXJuO1xuICAgIGlmICh0aGlzLmRlYnVnKSBjb25zb2xlLmluZm8oJ2ZpdCcpO1xuICAgIHRoaXMud2lkdGggPSAnYXV0byc7XG4gICAgdGhpcy5taW5XaWR0aCA9IG51bGw7XG4gICAgdGhpcy5tYXhXaWR0aCA9IG51bGw7XG4gICAgaWYgKCFvcHRzIHx8IG9wdHMuZW1pdEV2ZW50KSB7XG4gICAgICB0aGlzLnNpemVDaGFuZ2VkLmVtaXQodW5kZWZpbmVkKTtcbiAgICB9XG4gIH1cbn1cbiIsIjxkaXYgY2xhc3M9XCJ3cmFwcGVyXCI+XG4gIDxkaXYgY2xhc3M9XCJjb250ZW50XCI+XG4gICAgPG5nLWNvbnRlbnQ+PC9uZy1jb250ZW50PlxuICA8L2Rpdj5cbiAgPGRpdiBjbGFzcz1cImJhclwiIFtjbGFzcy5jZGstdmlzdWFsbHktaGlkZGVuXT1cIiFyZXNpemFibGVcIiAocmVzaXphYmxlKT1cIm9uUmVzaXplKCRldmVudClcIiAoZml0KT1cIm9uRml0KClcIj48L2Rpdj5cbjwvZGl2PlxuIl19

package/esm2020/src/app/shared/directives/resizable/resizable.directive.mjs

@@ -0,0 +1,40 @@
+import { DOCUMENT } from '@angular/common';
+import { Directive, ElementRef, Inject, Output } from '@angular/core';
+import { bufferWhen, distinctUntilChanged, filter, map, switchMap, takeUntil, tap } from 'rxjs/operators';
+import { fromEvent, interval } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ResizableDirective {
+    constructor(document, elementRef) {
+        this.document = document;
+        this.elementRef = elementRef;
+        // resize: mousedown -> mousemove -> mouseup
+        this.resizable = fromEvent(this.elementRef.nativeElement, 'mousedown').pipe(tap((e) => {
+            e.preventDefault();
+            e.stopPropagation();
+        }), switchMap(() => {
+            const { width, right } = this.elementRef.nativeElement.closest('th').getBoundingClientRect();
+            return fromEvent(this.document, 'mousemove').pipe(map(({ clientX }) => width + clientX - right), distinctUntilChanged(), takeUntil(fromEvent(this.document, 'mouseup')));
+        }));
+        // fit: doubleclick
+        this.fit = fromEvent(this.elementRef.nativeElement, 'click').pipe(bufferWhen(() => interval(500)), filter((ar) => ar.length === 2));
+    }
+}
+ResizableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ResizableDirective, deps: [{ token: DOCUMENT }, { token: ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+ResizableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: ResizableDirective, selector: "[resizable]", outputs: { resizable: "resizable", fit: "fit" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ResizableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[resizable]',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }]; }, propDecorators: { resizable: [{
+                type: Output
+            }], fit: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/app/shared/directives/resizable/resizable.module.mjs

@@ -0,0 +1,17 @@
+import { NgModule } from '@angular/core';
+import { ResizableComponent } from './resizable.component';
+import { ResizableDirective } from './resizable.directive';
+import * as i0 from "@angular/core";
+export class ResizableModule {
+}
+ResizableModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ResizableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ResizableModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: ResizableModule, declarations: [ResizableComponent, ResizableDirective], exports: [ResizableComponent, ResizableDirective] });
+ResizableModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ResizableModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ResizableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ResizableComponent, ResizableDirective],
+                    exports: [ResizableComponent, ResizableDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzaXphYmxlLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvc2hhcmVkL2RpcmVjdGl2ZXMvcmVzaXphYmxlL3Jlc2l6YWJsZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUMzRCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQzs7QUFNM0QsTUFBTSxPQUFPLGVBQWU7OzRHQUFmLGVBQWU7NkdBQWYsZUFBZSxpQkFIWCxrQkFBa0IsRUFBRSxrQkFBa0IsYUFDM0Msa0JBQWtCLEVBQUUsa0JBQWtCOzZHQUVyQyxlQUFlOzJGQUFmLGVBQWU7a0JBSjNCLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsa0JBQWtCLEVBQUUsa0JBQWtCLENBQUM7b0JBQ3RELE9BQU8sRUFBRSxDQUFDLGtCQUFrQixFQUFFLGtCQUFrQixDQUFDO2lCQUNsRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBSZXNpemFibGVDb21wb25lbnQgfSBmcm9tICcuL3Jlc2l6YWJsZS5jb21wb25lbnQnO1xuaW1wb3J0IHsgUmVzaXphYmxlRGlyZWN0aXZlIH0gZnJvbSAnLi9yZXNpemFibGUuZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbUmVzaXphYmxlQ29tcG9uZW50LCBSZXNpemFibGVEaXJlY3RpdmVdLFxuICBleHBvcnRzOiBbUmVzaXphYmxlQ29tcG9uZW50LCBSZXNpemFibGVEaXJlY3RpdmVdLFxufSlcbmV4cG9ydCBjbGFzcyBSZXNpemFibGVNb2R1bGUge31cbiJdfQ==

package/esm2020/src/app/shared/events.mjs

@@ -0,0 +1,64 @@
+import { EventEmitter } from '@angular/core';
+import { fromEvent, merge, timer } from 'rxjs';
+import { filter } from 'rxjs/operators';
+export function createPromiseEventEmitter() {
+    return new EventEmitter(true);
+}
+export function createPromiseEvent(eventType, promise, initArg) {
+    const detail = {
+        ...(initArg?.detail || {}),
+        ...promise
+    };
+    return new CustomEvent(eventType, { detail });
+}
+export function emitPromiseEvent(emitter, eventType, initArg) {
+    return new Promise((resolve, reject) => {
+        const event = createPromiseEvent(eventType, {
+            success: resolve,
+            error: reject
+        }, initArg);
+        emitter.emit(event);
+    });
+}
+/**
+ * Listen end of scroll.
+ * <p>
+ *   The threshold distance from the bottom of the content to call the infinite output event when scrolled.
+ *   The threshold value can be either a percent, or in pixels.
+ *   For example, use the value of 10% for the infinite output event to get called when the user has scrolled
+ *   10% from the bottom of the page. Use the value 100px when the scroll is within 100 pixels from the bottom of the page.
+ * </p>
+ * @param element
+ * @param threshold default to '15%'
+ */
+export function fromScrollEndEvent(element, threshold, dueTime) {
+    threshold = threshold || '15%';
+    let isEnd;
+    // Listen using percentage
+    if (threshold.endsWith('%')) {
+        const thresholdRatio = parseInt(threshold.slice(0, threshold.length - 1)) / 100;
+        isEnd = () => {
+            const endPosRatio = 1 - (element.scrollTop + element.offsetHeight) / element.scrollHeight;
+            return endPosRatio < thresholdRatio;
+        };
+    }
+    // Listen using pixels
+    else if (threshold.endsWith('px')) {
+        const thresholdPx = parseInt(threshold.slice(0, threshold.length - 2));
+        isEnd = () => {
+            const endPosPx = element.scrollHeight - (element.scrollTop + element.offsetHeight);
+            return endPosPx < thresholdPx;
+        };
+    }
+    else {
+        throw new Error('Invalid argument \'threshold\'. Expected value unit: \'px\' or \'%\' ');
+    }
+    // Check bottom reach, even if NO scroll event (e.g. when already reach the bottom)
+    if (dueTime > 0) {
+        return merge(fromEvent(element, 'scroll'), timer(dueTime))
+            .pipe(filter(() => isEnd()));
+    }
+    return fromEvent(element, 'scroll')
+        .pipe(filter(() => isEnd()));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/app/shared/file/csv.utils.mjs

@@ -0,0 +1,74 @@
+import { filter, map } from 'rxjs/operators';
+import { HttpEventType } from '@angular/common/http';
+import { FileResponse } from '../upload-file/upload-file.model';
+import { FilesUtils } from './file.utils';
+import { isNotNil } from '../functions';
+//@dynamic
+export class CsvUtils {
+    static exportToFile(rows, opts) {
+        if (!rows || !rows.length)
+            return; // Skip if empty
+        // Create text content
+        const separator = opts?.separator || ',';
+        const protectCellRegexp = new RegExp("/(\"|" + separator + "|\n)/g");
+        const keys = Object.keys(rows[0]);
+        const headers = opts?.headers || keys;
+        const textContent = 
+        // Header row
+        headers.join(separator) + '\n' +
+            // Data rows
+            rows.map(row => {
+                return keys.map(k => {
+                    const cell = row[k] === null || row[k] === undefined ? '' : row[k];
+                    let cellStr = cell instanceof Date
+                        ? cell.toLocaleString()
+                        : cell.toString().replace(/"/g, '""');
+                    if (protectCellRegexp.test(cellStr)) {
+                        cellStr = `"${cellStr}"`;
+                    }
+                    return cellStr;
+                }).join(separator);
+            }).join('\n');
+        // Write to file
+        FilesUtils.writeTextToFile(textContent, {
+            type: 'text/csv',
+            filename: 'export.csv',
+            ...opts,
+        });
+    }
+    static parseFile(file, opts) {
+        return FilesUtils.readAsText(file, opts?.encoding)
+            .pipe(map(e => {
+            if (e.type === HttpEventType.UploadProgress) {
+                const loaded = Math.round(e.loaded * 0.8);
+                return { ...e, loaded };
+            }
+            else if (e instanceof FileResponse) {
+                const body = e.body;
+                const data = CsvUtils.parseCSV(body, opts);
+                return new FileResponse({ body: data });
+            }
+        }), filter(isNotNil));
+    }
+    static parseCSV(body, opts) {
+        const separator = opts?.separator || ',';
+        const skipEmptyLine = !opts || opts.skipEmptyLine !== false;
+        // Protect special characters (quote and /n)
+        body = body.replace('""', '<quote>') // Protect double quote
+            .replace(/("[^\n"]+)\n\r?/gm, '"$1<br>') // Protect \n inside a quoted expression
+            .replace(/\n\r/gm, '\n'); // Windows CR
+        const headerAndRows = body.split('\n', 2);
+        const headers = headerAndRows[0].split(separator);
+        return body.split('\n') // split into rows
+            .filter(line => !skipEmptyLine || line.trim().length > 0) // Skip empty line
+            .map(line => {
+            const cells = line.split(separator, headers.length) // split into cells
+                .map(cell => cell.replace(/^"([^"]*)"$/, '$1')) // Clean trailing quotes
+                .map(cell => cell.replace('<quote>', '"')) // restore protected quote
+                .map(cell => cell.replace('<br>', '\n')) // restore protected br
+            ;
+            return cells;
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"csv.utils.js","sourceRoot":"","sources":["../../../../../../src/app/shared/file/csv.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {Observable} from 'rxjs';\nimport {filter, map} from 'rxjs/operators';\nimport {HttpEventType} from '@angular/common/http';\nimport {FileEvent, FileResponse} from '../upload-file/upload-file.model';\nimport {FilesUtils} from './file.utils';\nimport {isNotNil} from '../functions';\n\n//@dynamic\nexport class CsvUtils {\n\n  static exportToFile(rows: object[],\n                      opts?: {\n                        filename?: string;\n                        headers?: string[];\n                        separator?: string;\n                        encoding?: string;\n                        type?: string;\n                      }) {\n    if (!rows || !rows.length) return; // Skip if empty\n\n    // Create text content\n    const separator = opts?.separator || ',';\n    const protectCellRegexp = new RegExp(\"/(\\\"|\"+ separator +\"|\\n)/g\");\n    const keys = Object.keys(rows[0]);\n    const headers = opts?.headers || keys;\n    const textContent =\n      // Header row\n      headers.join(separator) + '\\n' +\n      // Data rows\n      rows.map(row => {\n        return keys.map(k => {\n          const cell = row[k] === null || row[k] === undefined ? '' : row[k];\n          let cellStr: string = cell instanceof Date\n            ? cell.toLocaleString()\n            : cell.toString().replace(/\"/g, '\"\"');\n          if (protectCellRegexp.test(cellStr)) {\n            cellStr = `\"${cellStr}\"`;\n          }\n          return cellStr;\n        }).join(separator);\n      }).join('\\n');\n\n    // Write to file\n    FilesUtils.writeTextToFile(\n      textContent, {\n        type: 'text/csv',\n        filename: 'export.csv',\n        ...opts,\n      }\n    );\n  }\n\n  static parseFile(file: File, opts?: {separator?: string; encoding?: string;}): Observable<FileEvent<string[][]>> {\n    return FilesUtils.readAsText(file, opts?.encoding)\n      .pipe(\n        map(e => {\n          if (e.type === HttpEventType.UploadProgress) {\n            const loaded = Math.round(e.loaded * 0.8);\n            return {...e, loaded};\n          }\n          else if (e instanceof FileResponse){\n            const body = e.body;\n            const data = CsvUtils.parseCSV(body, opts);\n            return new FileResponse<string[][]>({body: data});\n          }\n        }),\n        filter(isNotNil)\n      );\n  }\n\n  static parseCSV(body: string, opts?: {separator?: string; skipEmptyLine?: boolean}): string[][] {\n    const separator = opts?.separator || ',';\n    const skipEmptyLine = !opts || opts.skipEmptyLine !== false;\n\n    // Protect special characters (quote and /n)\n    body = body.replace('\"\"', '<quote>') // Protect double quote\n      .replace(/(\"[^\\n\"]+)\\n\\r?/gm, '\"$1<br>') // Protect \\n inside a quoted expression\n      .replace(/\\n\\r/gm, '\\n') // Windows CR\n\n    const headerAndRows = body.split('\\n', 2);\n    const headers = headerAndRows[0].split(separator);\n\n    return body.split('\\n') // split into rows\n      .filter(line => !skipEmptyLine || line.trim().length > 0) // Skip empty line\n      .map(line => {\n        const cells = line.split(separator, headers.length) // split into cells\n          .map(cell => cell.replace(/^\"([^\"]*)\"$/, '$1')) // Clean trailing quotes\n          .map(cell => cell.replace('<quote>', '\"')) // restore protected quote\n          .map(cell => cell.replace('<br>', '\\n')) // restore protected br\n        ;\n        return cells;\n      });\n  }\n}\n"]}

package/esm2020/src/app/shared/file/file.service.mjs

@@ -0,0 +1,117 @@
+import { Inject, Injectable } from '@angular/core';
+import { Platform } from '@ionic/angular';
+import { ImagesUtils } from './images.utils';
+import { chainPromises, firstNotNilPromise } from '../observables';
+import { HttpClient } from '@angular/common/http';
+import { ENVIRONMENT } from '../../../environments/environment.class';
+import { v4 as uuidv4 } from 'uuid';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+import * as i2 from "@angular/common/http";
+export class FileService {
+    constructor(platform, 
+    //private transfer: FileTransfer,
+    //@Optional() private file: File,
+    http, environment) {
+        this.platform = platform;
+        this.http = http;
+        this.environment = environment;
+        this._started = false;
+        this._debug = !environment.production;
+        platform.ready().then(() => this.start());
+    }
+    get canUseFileSystem() {
+        return false;
+        // FIXME: seems not working well
+        //return !!this.file.dataDirectory;
+    }
+    getImages(sources, opts) {
+        if (!this._started)
+            throw new Error('Platform must be started first!');
+        //const fileTransfer = this.canUseFileSystem ? this.transfer.create() : undefined;
+        //const jobsFactories = (sources || []).map(source => () => this.getImage(source, {...opts, fileTransfer}));
+        const jobsFactories = (sources || []).map(source => () => this.getImage(source, { ...opts }));
+        return chainPromises(jobsFactories);
+    }
+    async getImage(fileUrl, opts) {
+        let outputType = opts && opts.outputType || (this.canUseFileSystem ? 'fileUrl' : 'dataUrl');
+        const debug = this._debug /*&& (!opts || !opts.fileTransfer)*/;
+        const now = debug && Date.now();
+        if (debug)
+            console.debug(`[file] Fetching image {${fileUrl}} into ${outputType}...`);
+        // Read the filename
+        const lastSlashIndex = fileUrl.lastIndexOf('/');
+        if (lastSlashIndex === -1)
+            throw new Error('Invalid URL: ' + fileUrl);
+        const fileName = lastSlashIndex < (fileUrl.length - 1) && fileUrl.substring(lastSlashIndex + 1) || uuidv4();
+        // Download into the file system
+        if (outputType === 'fileUrl' && this.canUseFileSystem) {
+            console.warn(`WARN: [file] Downloading image {${fileUrl}} in local filesystem...`);
+            const targetFilePath = this._imageDirectory + fileName;
+            try {
+                const blob = await firstNotNilPromise(this.http.get(fileUrl, {
+                    observe: 'body',
+                    responseType: 'blob',
+                    reportProgress: false
+                }));
+                console.debug('[file] Getting blob :' + blob.type);
+                //await this.file.writeFile(this._imageDirectory, fileName, blob, {replace: true});
+                //const fileTransfer = (opts && opts.fileTransfer) || this.transfer.create();
+                //await fileTransfer.download(source, targetFilePath);
+                if (debug)
+                    console.debug(`[file] Fetching image {${fileUrl}} into ${outputType} [OK] in ${Date.now() - now}ms`);
+                return targetFilePath;
+            }
+            catch (err) {
+                console.error(`[file] Error while download ${fileUrl}: ${err && err.message || err}`);
+                // Continue (fallback to data Url)
+                outputType = 'dataUrl';
+            }
+        }
+        if (outputType === 'dataUrl') {
+            // Get as data url (e.g. 'data:image/png:...')
+            const dataUrl = await ImagesUtils.readAndResizeFromUrl(fileUrl, opts);
+            if (debug)
+                console.debug(`[file] Fetching image {${fileUrl}} into ${outputType} [OK] in ${Date.now() - now}ms`);
+            return dataUrl;
+        }
+        // Keep original URL
+        return fileUrl;
+    }
+    /* -- protected methods -- */
+    start() {
+        // File system exists
+        if (this.canUseFileSystem) {
+            //console.info("[file] Application directory: ", this.file.applicationDirectory);
+            //console.info("[file] Application storage directory: ", this.file.applicationStorageDirectory);
+            //console.info("[file] Data directory: ", this.file.dataDirectory);
+            // this.file.createDir(this.file.dataDirectory, 'images', false)
+            //   .then((dir) => {
+            //     this._imageDirectory = this.file.dataDirectory + 'images/';
+            //     console.info("[file] Images directory: ", dir.fullPath);
+            //   })
+            //   .catch(err => {
+            //     console.error("[file] Cannot create the images directory: " + (this.file.dataDirectory + 'images/ : ' + (err && err.message || err)));
+            //     this._imageDirectory = this.file.dataDirectory;
+            //   });
+        }
+        this._started = true;
+    }
+}
+FileService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: FileService, deps: [{ token: i1.Platform }, { token: i2.HttpClient }, { token: ENVIRONMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+FileService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: FileService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: FileService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                    deps: [
+                        Platform,
+                        HttpClient,
+                        ENVIRONMENT
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Platform }, { type: i2.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ENVIRONMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file.service.js","sourceRoot":"","sources":["../../../../../../src/app/shared/file/file.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable} from '@angular/core';\nimport {Platform} from '@ionic/angular';\nimport {ImagesUtils, ImageResizeOptions} from './images.utils';\nimport {chainPromises, firstNotNilPromise} from '../observables';\nimport {HttpClient} from '@angular/common/http';\nimport {ENVIRONMENT} from '../../../environments/environment.class';\nimport {v4 as uuidv4} from 'uuid';\n\n@Injectable({\n  providedIn: 'root',\n  deps: [\n    Platform,\n    HttpClient,\n    ENVIRONMENT\n  ]\n})\nexport class FileService {\n\n  private readonly _debug: boolean;\n  private _started = false;\n\n  private _imageDirectory: string;\n\n  get canUseFileSystem(): boolean {\n    return false;\n    // FIXME: seems not working well\n    //return !!this.file.dataDirectory;\n  }\n\n  constructor(\n    private platform: Platform,\n    //private transfer: FileTransfer,\n    //@Optional() private file: File,\n    private http: HttpClient,\n    @Inject(ENVIRONMENT) protected environment) {\n\n    this._debug = !environment.production;\n\n    platform.ready().then(() => this.start());\n  }\n\n  getImages(sources: string[], opts?: ImageResizeOptions & {\n    outputType?: 'fileUrl' | 'dataUrl';\n  }): Promise<string[]> {\n    if (!this._started) throw new Error('Platform must be started first!');\n\n    //const fileTransfer = this.canUseFileSystem ? this.transfer.create() : undefined;\n    //const jobsFactories = (sources || []).map(source => () => this.getImage(source, {...opts, fileTransfer}));\n\n    const jobsFactories = (sources || []).map(source => () => this.getImage(source, {...opts}));\n    return chainPromises<string>(jobsFactories);\n  }\n\n  async getImage(fileUrl: string, opts?: ImageResizeOptions & {\n    outputType?: 'fileUrl' | 'dataUrl';\n    }): Promise<string> {\n\n    let outputType = opts && opts.outputType || (this.canUseFileSystem ? 'fileUrl' : 'dataUrl');\n\n    const debug = this._debug /*&& (!opts || !opts.fileTransfer)*/;\n    const now = debug && Date.now();\n    if (debug) console.debug(`[file] Fetching image {${fileUrl}} into ${outputType}...`);\n\n    // Read the filename\n    const lastSlashIndex = fileUrl.lastIndexOf('/');\n    if (lastSlashIndex === -1) throw new Error('Invalid URL: ' + fileUrl);\n    const fileName = lastSlashIndex < (fileUrl.length - 1) && fileUrl.substring(lastSlashIndex + 1) || uuidv4();\n\n\n    // Download into the file system\n    if (outputType === 'fileUrl' && this.canUseFileSystem) {\n      console.warn(`WARN: [file] Downloading image {${fileUrl}} in local filesystem...`);\n      const targetFilePath = this._imageDirectory + fileName;\n      try {\n        const blob: Blob = await firstNotNilPromise(this.http.get(fileUrl, {\n          observe: 'body',\n          responseType: 'blob',\n          reportProgress: false\n        }));\n        console.debug('[file] Getting blob :' + blob.type);\n\n        //await this.file.writeFile(this._imageDirectory, fileName, blob, {replace: true});\n\n        //const fileTransfer = (opts && opts.fileTransfer) || this.transfer.create();\n        //await fileTransfer.download(source, targetFilePath);\n        if (debug) console.debug(`[file] Fetching image {${fileUrl}} into ${outputType} [OK] in ${Date.now() - now}ms`);\n        return targetFilePath;\n      }\n      catch (err) {\n        console.error(`[file] Error while download ${fileUrl}: ${err && err.message || err}`);\n\n        // Continue (fallback to data Url)\n        outputType = 'dataUrl';\n      }\n    }\n\n    if (outputType === 'dataUrl') {\n      // Get as data url (e.g. 'data:image/png:...')\n      const dataUrl = await ImagesUtils.readAndResizeFromUrl(fileUrl, opts);\n      if (debug) console.debug(`[file] Fetching image {${fileUrl}} into ${outputType} [OK] in ${Date.now() - now}ms`);\n      return dataUrl;\n    }\n\n    // Keep original URL\n    return fileUrl;\n  }\n\n  /* -- protected methods -- */\n\n  protected start() {\n\n    // File system exists\n    if (this.canUseFileSystem) {\n      //console.info(\"[file] Application directory: \", this.file.applicationDirectory);\n      //console.info(\"[file] Application storage directory: \", this.file.applicationStorageDirectory);\n      //console.info(\"[file] Data directory: \", this.file.dataDirectory);\n\n      // this.file.createDir(this.file.dataDirectory, 'images', false)\n      //   .then((dir) => {\n      //     this._imageDirectory = this.file.dataDirectory + 'images/';\n      //     console.info(\"[file] Images directory: \", dir.fullPath);\n      //   })\n      //   .catch(err => {\n      //     console.error(\"[file] Cannot create the images directory: \" + (this.file.dataDirectory + 'images/ : ' + (err && err.message || err)));\n      //     this._imageDirectory = this.file.dataDirectory;\n      //   });\n    }\n\n    this._started = true;\n  }\n\n}\n"]}