@sumaris-net/ngx-components 1.2.7 → 1.2.14

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"]}

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

@@ -0,0 +1,33 @@
+import { FilesUtils } from './file.utils';
+import { decodeUTF8 } from 'tweetnacl-util';
+//@dynamic
+export class JsonUtils {
+    static exportToFile(content, opts) {
+        if (!content || typeof content !== 'object')
+            return; // Skip if empty
+        // Create text content
+        const textContent = JSON.stringify(content);
+        // Write to file
+        FilesUtils.writeTextToFile(textContent, {
+            type: 'application/json',
+            filename: 'export.json',
+            ...opts,
+        });
+    }
+    static writeToFile(content, opts) {
+        if (!content || typeof content !== 'object')
+            return; // Skip if empty
+        opts = {
+            type: 'application/json',
+            filename: 'export.json',
+            ...opts,
+        };
+        // Create text content
+        const arrayUt8 = decodeUTF8(JSON.stringify(content));
+        const blob = new Blob([arrayUt8], { type: opts.type });
+        blob['lastModifiedDate'] = (new Date()).toISOString();
+        blob['name'] = opts.filename;
+        return blob;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,23 @@
+export class UriUtils {
+    /**
+     * Extract the filename, from an uri (using the last slash)
+     * @param uri
+     */
+    static getFilename(uri) {
+        if (!uri)
+            return uri;
+        let filename = uri.trim();
+        // Get last part (or all string, if no '/')
+        const lastSlashIndex = filename.lastIndexOf('/');
+        if (lastSlashIndex !== -1 && lastSlashIndex !== uri.length - 1) {
+            filename = filename.substring(lastSlashIndex + 1);
+        }
+        // Remove query params
+        const queryParamIndex = filename.indexOf('?');
+        if (queryParamIndex !== -1) {
+            filename = filename.substring(0, queryParamIndex);
+        }
+        return filename;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXJpLnV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9zaGFyZWQvZmlsZS91cmkudXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLFFBQVE7SUFFbkI7OztPQUdHO0lBQ0gsTUFBTSxDQUFDLFdBQVcsQ0FBQyxHQUFXO1FBQzVCLElBQUksQ0FBQyxHQUFHO1lBQUUsT0FBTyxHQUFHLENBQUM7UUFDckIsSUFBSSxRQUFRLEdBQUcsR0FBRyxDQUFDLElBQUksRUFBRSxDQUFDO1FBRTFCLDJDQUEyQztRQUMzQyxNQUFNLGNBQWMsR0FBRyxRQUFRLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ2pELElBQUksY0FBYyxLQUFLLENBQUMsQ0FBQyxJQUFJLGNBQWMsS0FBSyxHQUFHLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRTtZQUM5RCxRQUFRLEdBQUcsUUFBUSxDQUFDLFNBQVMsQ0FBQyxjQUFjLEdBQUcsQ0FBQyxDQUFDLENBQUM7U0FDbkQ7UUFFRCxzQkFBc0I7UUFDdEIsTUFBTSxlQUFlLEdBQUcsUUFBUSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUM5QyxJQUFJLGVBQWUsS0FBSyxDQUFDLENBQUMsRUFBRTtZQUMxQixRQUFRLEdBQUcsUUFBUSxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsZUFBZSxDQUFDLENBQUM7U0FDbkQ7UUFFRCxPQUFPLFFBQVEsQ0FBQztJQUNsQixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgVXJpVXRpbHMge1xuXG4gIC8qKlxuICAgKiBFeHRyYWN0IHRoZSBmaWxlbmFtZSwgZnJvbSBhbiB1cmkgKHVzaW5nIHRoZSBsYXN0IHNsYXNoKVxuICAgKiBAcGFyYW0gdXJpXG4gICAqL1xuICBzdGF0aWMgZ2V0RmlsZW5hbWUodXJpOiBzdHJpbmcpOiBzdHJpbmcge1xuICAgIGlmICghdXJpKSByZXR1cm4gdXJpO1xuICAgIGxldCBmaWxlbmFtZSA9IHVyaS50cmltKCk7XG5cbiAgICAvLyBHZXQgbGFzdCBwYXJ0IChvciBhbGwgc3RyaW5nLCBpZiBubyAnLycpXG4gICAgY29uc3QgbGFzdFNsYXNoSW5kZXggPSBmaWxlbmFtZS5sYXN0SW5kZXhPZignLycpO1xuICAgIGlmIChsYXN0U2xhc2hJbmRleCAhPT0gLTEgJiYgbGFzdFNsYXNoSW5kZXggIT09IHVyaS5sZW5ndGggLSAxKSB7XG4gICAgICBmaWxlbmFtZSA9IGZpbGVuYW1lLnN1YnN0cmluZyhsYXN0U2xhc2hJbmRleCArIDEpO1xuICAgIH1cblxuICAgIC8vIFJlbW92ZSBxdWVyeSBwYXJhbXNcbiAgICBjb25zdCBxdWVyeVBhcmFtSW5kZXggPSBmaWxlbmFtZS5pbmRleE9mKCc/Jyk7XG4gICAgaWYgKHF1ZXJ5UGFyYW1JbmRleCAhPT0gLTEpIHtcbiAgICAgIGZpbGVuYW1lID0gZmlsZW5hbWUuc3Vic3RyaW5nKDAsIHF1ZXJ5UGFyYW1JbmRleCk7XG4gICAgfVxuXG4gICAgcmV0dXJuIGZpbGVuYW1lO1xuICB9XG59XG4iXX0=