@sumaris-net/ngx-components 1.23.8 → 2.0.0-rc1

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 { v4 as uuidv4 } from 'uuid';
+import { ImagesUtils } from './images.utils';
+import { chainPromises, firstNotNilPromise } from '../observables';
+import { HttpClient } from '@angular/common/http';
+import { ENVIRONMENT } from '../../../environments/environment.class';
+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.2.1", 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.2.1", ngImport: i0, type: FileService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", 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 { v4 as uuidv4 } from 'uuid';\nimport {ImagesUtils, ImageResizeOptions} from './images.utils';\nimport {chainPromises, firstNotNilPromise} from '../observables';\nimport {HttpClient} from '@angular/common/http';\nimport {ENVIRONMENT} from '../../../environments/environment.class';\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"]}

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

@@ -0,0 +1,113 @@
+import { FileResponse } from '../upload-file/upload-file.model';
+import { UploadFilePopover } from '../upload-file/upload-file-popover.component';
+import { Subject } from 'rxjs';
+import { HttpEventType } from '@angular/common/http';
+import { isNilOrBlank } from '../functions';
+export const MimeTypes = Object.freeze({
+    ANDROID_APK: 'application/vnd.android.package-archive'
+});
+export class FilesUtils {
+    static async showUploadPopover(popoverController, event, opts) {
+        const modal = await popoverController.create({
+            component: UploadFilePopover,
+            componentProps: opts,
+            backdropDismiss: false,
+            keyboardClose: false,
+            event,
+            translucent: true,
+            cssClass: 'popover-large',
+        });
+        await modal.present();
+        const { data, role } = await modal.onDidDismiss();
+        return {
+            role,
+            data: data ? data : undefined
+        };
+    }
+    static readAsText(file, encoding) {
+        const $progress = new Subject();
+        const reader = new FileReader();
+        encoding = (encoding || 'UTF-8').toLowerCase();
+        // Listen progress
+        reader.onprogress = (e) => {
+            const total = e.total || 1;
+            const loaded = e.total || 0;
+            if (loaded < total)
+                $progress.next({ type: HttpEventType.UploadProgress, loaded, total });
+        };
+        // Listen end
+        reader.onloadend = (_) => {
+            const body = reader.result;
+            if (typeof body === 'string') {
+                $progress.next(new FileResponse({ body }));
+                $progress.complete();
+            }
+            else {
+                console.error(`Cannot read file '${file.name}' as text`);
+                $progress.error(`Cannot read file as text`);
+            }
+        };
+        // Listen error
+        reader.onerror = (event) => {
+            console.error('[files] Error while reading file:', event);
+            $progress.error(event);
+        };
+        // Start reading the file
+        reader.readAsText(file, encoding);
+        return $progress.asObservable();
+    }
+    static writeTextToFile(content, opts) {
+        if (isNilOrBlank(content))
+            return; // Skip if empty
+        const filename = opts?.filename || 'export.txt';
+        const charset = (opts?.encoding || 'utf-8').toLowerCase();
+        let type = opts?.type || 'text/plain';
+        const blob = new Blob((charset === 'utf-8')
+            // Add UTF-8 BOM character
+            ? [FilesUtils.UTF8_BOM_CHAR, content]
+            // Non UTF-8 charset
+            : [content], { type: `${type};charset=${charset};` });
+        if (navigator.msSaveBlob) { // IE 10+
+            navigator.msSaveBlob(blob, filename);
+        }
+        else {
+            const link = document.createElement('a');
+            if (link.download !== undefined) {
+                // Browsers that support HTML5 download attribute
+                const url = URL.createObjectURL(blob);
+                link.setAttribute('href', url);
+                link.setAttribute('download', filename);
+                link.style.visibility = 'hidden';
+                document.body.appendChild(link);
+                link.click();
+                document.body.removeChild(link);
+            }
+        }
+    }
+    static downloadUri(uri, filename) {
+        if (navigator.msLaunchUri) { // IE 10+
+            navigator.msLaunchUri(uri);
+        }
+        else {
+            filename = filename || this.getFilenameFromUri(uri);
+            const link = document.createElement('a');
+            if (link.download !== undefined) {
+                // Browsers that support HTML5 download attribute
+                link.setAttribute('href', uri);
+                link.setAttribute('download', filename);
+                link.style.visibility = 'hidden';
+                document.body.appendChild(link);
+                link.click();
+                document.body.removeChild(link);
+            }
+        }
+    }
+    static getFilenameFromUri(uri) {
+        const lastSlashIndex = uri?.lastIndexOf('/');
+        if (lastSlashIndex === -1 || lastSlashIndex === uri.length - 1)
+            throw new Error('Invalid URI format. No slash found');
+        return uri.substring(lastSlashIndex + 1);
+    }
+}
+FilesUtils.UTF8_BOM_CHAR = new Uint8Array([0xEF, 0xBB, 0xBF]); // UTF-8 BOM
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file.utils.js","sourceRoot":"","sources":["../../../../../../src/app/shared/file/file.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {FileEvent, FileResponse, UploadFile} from '../upload-file/upload-file.model';\nimport {UploadFilePopover, UploadFilePopoverOptions} from '../upload-file/upload-file-popover.component';\n\nimport {PopoverController} from '@ionic/angular';\nimport {Observable, Subject} from 'rxjs';\nimport {HttpEventType} from '@angular/common/http';\nimport {OverlayEventDetail} from '@ionic/core';\nimport {isNilOrBlank} from '../functions';\n\nexport const MimeTypes = Object.freeze({\n  ANDROID_APK: 'application/vnd.android.package-archive'\n});\n\n\nexport class FilesUtils {\n\n  static UTF8_BOM_CHAR = new Uint8Array([0xEF, 0xBB, 0xBF]); // UTF-8 BOM\n\n  static async showUploadPopover<T>(popoverController: PopoverController,\n                                 event: Event,\n                                 opts: UploadFilePopoverOptions<T>): Promise<OverlayEventDetail<UploadFile<T>[]>> {\n    const modal = await popoverController.create({\n      component: UploadFilePopover,\n      componentProps: opts,\n      backdropDismiss: false,\n      keyboardClose: false,\n      event,\n      translucent: true,\n      cssClass: 'popover-large',\n    });\n\n    await modal.present();\n    const { data, role } = await modal.onDidDismiss();\n    return {\n      role,\n      data: data ? data as UploadFile<T>[] : undefined\n    };\n  }\n\n  static readAsText(file: File, encoding?: string): Observable<FileEvent<string>> {\n\n    const $progress = new Subject<FileEvent<string>>();\n    const reader = new FileReader();\n    encoding = (encoding || 'UTF-8').toLowerCase();\n\n    // Listen progress\n    reader.onprogress = (e: ProgressEvent) => {\n      const total = e.total || 1;\n      const loaded = e.total || 0;\n      if (loaded < total) $progress.next({type: HttpEventType.UploadProgress, loaded, total});\n    }\n\n    // Listen end\n    reader.onloadend = (_) => {\n      const body = reader.result;\n      if (typeof body === 'string') {\n        $progress.next(new FileResponse({body}));\n        $progress.complete();\n      }\n      else {\n        console.error(`Cannot read file '${file.name}' as text`);\n        $progress.error(`Cannot read file as text`);\n      }\n    }\n\n    // Listen error\n    reader.onerror = (event: ProgressEvent) => {\n      console.error('[files] Error while reading file:', event);\n      $progress.error(event);\n    }\n\n    // Start reading the file\n    reader.readAsText(file, encoding);\n\n    return $progress.asObservable();\n  }\n\n  static writeTextToFile(content: string,\n                         opts?: {\n                           filename?: string;\n                           encoding?: string;\n                           type?: string;\n                         }) {\n    if (isNilOrBlank(content)) return; // Skip if empty\n\n    const filename = opts?.filename || 'export.txt';\n    const charset = (opts?.encoding || 'utf-8').toLowerCase();\n    let type = opts?.type || 'text/plain';\n    const blob = new Blob((charset === 'utf-8')\n        // Add UTF-8 BOM character\n        ? [FilesUtils.UTF8_BOM_CHAR, content]\n        // Non UTF-8 charset\n        : [content],\n      { type: `${type};charset=${charset};` });\n    if ((navigator as any).msSaveBlob) { // IE 10+\n      (navigator as any).msSaveBlob(blob, filename);\n    } else {\n      const link = document.createElement('a');\n      if (link.download !== undefined) {\n        // Browsers that support HTML5 download attribute\n        const url = URL.createObjectURL(blob);\n        link.setAttribute('href', url);\n        link.setAttribute('download', filename);\n        link.style.visibility = 'hidden';\n        document.body.appendChild(link);\n        link.click();\n        document.body.removeChild(link);\n      }\n    }\n  }\n\n  static downloadUri(uri: string,\n                     filename?: string) {\n    if ((navigator as any).msLaunchUri) { // IE 10+\n      (navigator as any).msLaunchUri(uri);\n    }\n    else {\n      filename = filename || this.getFilenameFromUri(uri);\n      const link = document.createElement('a');\n      if (link.download !== undefined) {\n        // Browsers that support HTML5 download attribute\n        link.setAttribute('href', uri);\n        link.setAttribute('download', filename);\n        link.style.visibility = 'hidden';\n        document.body.appendChild(link);\n        link.click();\n        document.body.removeChild(link);\n      }\n    }\n  }\n\n  static getFilenameFromUri(uri: string): string {\n    const lastSlashIndex = uri?.lastIndexOf('/');\n    if (lastSlashIndex === -1 || lastSlashIndex === uri.length - 1) throw new Error('Invalid URI format. No slash found');\n    return uri.substring(lastSlashIndex + 1);\n  }\n}\n\n"]}

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

@@ -0,0 +1,161 @@
+import { isNilOrBlank } from '../functions';
+import { Subject } from 'rxjs';
+import { FileResponse } from '../upload-file/upload-file.model';
+import { HttpEventType } from '@angular/common/http';
+import { mergeMap } from 'rxjs/operators';
+export const IMAGE_DEFAULTS = {
+    MAX_HEIGHT: 480,
+    MAX_WIDTH: 640,
+    THUMB_MAX_HEIGHT: 200,
+    THUMB_MAX_WIDTH: 200
+};
+// @dynamic
+export class ImagesUtils {
+    static readAsDataURL(file, opts) {
+        const $progress = new Subject();
+        const reader = new FileReader();
+        // Listen progress
+        reader.onprogress = (e) => {
+            const total = e.total || 1;
+            const loaded = e.total || 0;
+            if (loaded < total)
+                $progress.next({ type: HttpEventType.UploadProgress, loaded, total });
+        };
+        // Listen end
+        reader.onloadend = (e) => {
+            const body = reader.result;
+            if (typeof body === 'string') {
+                $progress.next(new FileResponse({ body }));
+                $progress.complete();
+            }
+            else {
+                console.error(`[image-utils] Cannot read file '${file.name}' as text`);
+                $progress.error(`Cannot read file as text`);
+            }
+        };
+        // Listen error
+        reader.onerror = (event) => {
+            console.error('[image-utils] Error while reading file:', event);
+            $progress.error(event);
+        };
+        // Start reading the file
+        reader.readAsDataURL(file);
+        // Resize image, if need
+        if (opts) {
+            return $progress.pipe(mergeMap(async (event) => {
+                if (event instanceof FileResponse) {
+                    const body = await ImagesUtils.resizeBase64(event.body, opts);
+                    return new FileResponse({ body });
+                }
+                return event;
+            }));
+        }
+        return $progress.asObservable();
+    }
+    static async readAndResizeFromUrl(fileUrl, opts) {
+        if (isNilOrBlank(fileUrl))
+            throw new Error('Illegal argument: missing fileUrl');
+        // Create the temporary image element
+        const img = document.createElement('img');
+        // Need to avoid CORS error
+        // (see https://stackoverflow.com/questions/22710627/tainted-canvases-may-not-be-exported)
+        img.crossOrigin = 'anonymous';
+        try {
+            return await new Promise((resolve, reject) => {
+                img.addEventListener('load', ImagesUtils.createImageOnLoadResizeFn(resolve, reject, opts), false);
+                img.addEventListener('error', reject);
+                img.src = fileUrl;
+            });
+        }
+        catch (err) {
+            throw new Error(`Failed to load and resize image {${fileUrl}}`);
+        }
+        finally {
+            img.remove();
+        }
+    }
+    static async resizeBase64(dataUrl, opts) {
+        // Create the temporary image element
+        const img = document.createElement('img');
+        // Need to avoid CORS error
+        // (see https://stackoverflow.com/questions/22710627/tainted-canvases-may-not-be-exported)
+        img.crossOrigin = 'anonymous';
+        try {
+            return await new Promise((resolve, reject) => {
+                img.addEventListener('load', ImagesUtils.createImageOnLoadResizeFn(resolve, reject, opts), false);
+                img.addEventListener('error', reject);
+                img.src = dataUrl;
+            });
+        }
+        finally {
+            img.remove();
+        }
+    }
+    static createImageOnLoadResizeFn(resolve, reject, opts) {
+        return function (event) {
+            const maxWidth = (opts && opts.thumbnail ? IMAGE_DEFAULTS.THUMB_MAX_WIDTH : (opts && opts.maxWidth || IMAGE_DEFAULTS.MAX_WIDTH));
+            const maxHeight = (opts && opts.thumbnail ? IMAGE_DEFAULTS.THUMB_MAX_HEIGHT : (opts && opts.maxHeight || IMAGE_DEFAULTS.MAX_HEIGHT));
+            let width = event.target.width;
+            let height = event.target.height;
+            const canvas = document.createElement('canvas');
+            let ctx;
+            try {
+                // Thumbnail: resize and crop (to the expected size)
+                if (opts && opts.thumbnail) {
+                    // landscape
+                    if (width > height) {
+                        width *= maxHeight / height;
+                        height = maxHeight;
+                    }
+                    // portrait
+                    else {
+                        height *= maxWidth / width;
+                        width = maxWidth;
+                    }
+                    canvas.width = maxWidth;
+                    canvas.height = maxHeight;
+                    ctx = canvas.getContext('2d');
+                    const xoffset = Math.trunc((maxWidth - width) / 2 + 0.5);
+                    const yoffset = Math.trunc((maxHeight - height) / 2 + 0.5);
+                    ctx.drawImage(event.target, xoffset, // x1
+                    yoffset, // y1
+                    maxWidth + -2 * xoffset, // x2
+                    maxHeight + -2 * yoffset // y2
+                    );
+                }
+                // Resize, but keep the full image
+                else {
+                    // landscape
+                    if (width > height) {
+                        if (width > maxWidth) {
+                            height *= maxWidth / width;
+                            width = maxWidth;
+                        }
+                    }
+                    // portrait
+                    else {
+                        if (height > maxHeight) {
+                            width *= maxHeight / height;
+                            height = maxHeight;
+                        }
+                    }
+                    canvas.width = width;
+                    canvas.height = height;
+                    ctx = canvas.getContext('2d');
+                    // Resize the whole image
+                    ctx.drawImage(event.target, 0, 0, canvas.width, canvas.height);
+                }
+                // Get image content as data URL
+                const base64 = canvas.toDataURL();
+                resolve(base64);
+            }
+            catch (err) {
+                reject(err);
+            }
+            finally {
+                canvas.remove();
+            }
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"images.utils.js","sourceRoot":"","sources":["../../../../../../src/app/shared/file/images.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {isNilOrBlank} from '../functions';\nimport {Observable, Subject} from 'rxjs';\nimport {FileEvent, FileResponse} from '../upload-file/upload-file.model';\nimport {HttpEventType} from '@angular/common/http';\nimport {mergeMap} from 'rxjs/operators';\n\nexport const IMAGE_DEFAULTS = {\n  MAX_HEIGHT: 480,\n  MAX_WIDTH: 640,\n  THUMB_MAX_HEIGHT: 200,\n  THUMB_MAX_WIDTH: 200\n};\n\nexport declare interface ImageResizeOptions {\n  maxWidth?: number;\n  maxHeight?: number;\n  thumbnail?: boolean;\n}\n\n// @dynamic\nexport class ImagesUtils {\n\n  static readAsDataURL(file: File, opts?: ImageResizeOptions): Observable<FileEvent<string>> {\n\n    const $progress = new Subject<FileEvent<string>>();\n    const reader = new FileReader();\n\n    // Listen progress\n    reader.onprogress = (e: ProgressEvent) => {\n      const total = e.total || 1;\n      const loaded = e.total || 0;\n      if (loaded < total) $progress.next({type: HttpEventType.UploadProgress, loaded, total});\n    }\n\n    // Listen end\n    reader.onloadend = (e: ProgressEvent) => {\n      const body = reader.result;\n      if (typeof body === 'string') {\n        $progress.next(new FileResponse({body}));\n        $progress.complete();\n      }\n      else {\n        console.error(`[image-utils] Cannot read file '${file.name}' as text`);\n        $progress.error(`Cannot read file as text`);\n      }\n    }\n\n    // Listen error\n    reader.onerror = (event: ProgressEvent) => {\n      console.error('[image-utils] Error while reading file:', event);\n      $progress.error(event);\n    }\n\n    // Start reading the file\n    reader.readAsDataURL(file);\n\n    // Resize image, if need\n    if (opts) {\n      return $progress.pipe(\n        mergeMap(async (event) => {\n          if (event instanceof FileResponse) {\n            const body = await ImagesUtils.resizeBase64(event.body, opts);\n            return new FileResponse({body})\n          }\n          return event;\n        })\n      );\n    }\n\n    return $progress.asObservable();\n  }\n\n  static async readAndResizeFromUrl(fileUrl: string, opts?: ImageResizeOptions): Promise<string> {\n    if (isNilOrBlank(fileUrl)) throw new Error('Illegal argument: missing fileUrl');\n\n    // Create the temporary image element\n    const img = document.createElement('img');\n\n    // Need to avoid CORS error\n    // (see https://stackoverflow.com/questions/22710627/tainted-canvases-may-not-be-exported)\n    img.crossOrigin = 'anonymous';\n\n    try {\n      return await new Promise<string>((resolve, reject) => {\n        img.addEventListener('load', ImagesUtils.createImageOnLoadResizeFn(resolve, reject, opts), false);\n        img.addEventListener('error', reject);\n        img.src = fileUrl;\n      });\n    }\n    catch (err) {\n      throw new Error(`Failed to load and resize image {${fileUrl}}`);\n    }\n    finally {\n      img.remove();\n    }\n  }\n\n\n  static async resizeBase64(dataUrl: string, opts?: ImageResizeOptions): Promise<string> {\n    // Create the temporary image element\n    const img = document.createElement('img');\n\n    // Need to avoid CORS error\n    // (see https://stackoverflow.com/questions/22710627/tainted-canvases-may-not-be-exported)\n    img.crossOrigin = 'anonymous';\n\n    try {\n      return await new Promise<string>((resolve, reject) => {\n        img.addEventListener('load', ImagesUtils.createImageOnLoadResizeFn(resolve, reject, opts), false);\n        img.addEventListener('error', reject);\n        img.src = dataUrl;\n      });\n    }\n    finally {\n      img.remove();\n    }\n  }\n\n  protected static createImageOnLoadResizeFn(resolve, reject, opts?: ImageResizeOptions) {\n    return function(event) {\n      const\n        maxWidth = (opts && opts.thumbnail ? IMAGE_DEFAULTS.THUMB_MAX_WIDTH : (opts && opts.maxWidth || IMAGE_DEFAULTS.MAX_WIDTH));\n        const maxHeight = (opts && opts.thumbnail ? IMAGE_DEFAULTS.THUMB_MAX_HEIGHT : (opts && opts.maxHeight || IMAGE_DEFAULTS.MAX_HEIGHT));\n      let width = event.target.width;\n        let height = event.target.height;\n\n      const canvas = document.createElement('canvas');\n      let ctx;\n\n      try {\n        // Thumbnail: resize and crop (to the expected size)\n        if (opts && opts.thumbnail) {\n\n          // landscape\n          if (width > height) {\n            width *= maxHeight / height;\n            height = maxHeight;\n          }\n\n          // portrait\n          else {\n            height *= maxWidth / width;\n            width = maxWidth;\n          }\n          canvas.width = maxWidth;\n          canvas.height = maxHeight;\n          ctx = canvas.getContext('2d');\n          const xoffset = Math.trunc((maxWidth - width) / 2 + 0.5);\n          const yoffset = Math.trunc((maxHeight - height) / 2 + 0.5);\n          ctx.drawImage(event.target,\n            xoffset, // x1\n            yoffset, // y1\n            maxWidth + -2 * xoffset, // x2\n            maxHeight + -2 * yoffset // y2\n          );\n        }\n\n        // Resize, but keep the full image\n        else {\n\n          // landscape\n          if (width > height) {\n            if (width > maxWidth) {\n              height *= maxWidth / width;\n              width = maxWidth;\n            }\n          }\n\n          // portrait\n          else {\n            if (height > maxHeight) {\n              width *= maxHeight / height;\n              height = maxHeight;\n            }\n          }\n\n          canvas.width = width;\n          canvas.height = height;\n          ctx = canvas.getContext('2d');\n\n          // Resize the whole image\n          ctx.drawImage(event.target, 0, 0, canvas.width, canvas.height);\n        }\n\n        // Get image content as data URL\n        const base64 = canvas.toDataURL();\n        resolve(base64);\n      }\n      catch (err) {\n        reject(err);\n      }\n      finally {\n        canvas.remove();\n      }\n\n    };\n  }\n}\n"]}