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

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

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

@@ -0,0 +1,51 @@
+import { FilesUtils } from './file.utils';
+import { decodeUTF8 } from 'tweetnacl-util';
+import { FileResponse } from '../upload-file/upload-file.model';
+import { filter, map } from 'rxjs/operators';
+import { HttpEventType } from '@angular/common/http';
+import { isNil, isNotNil } from '../functions';
+//@dynamic
+export class JsonUtils {
+    static exportToFile(content, opts) {
+        if (isNil(content))
+            return; // Skip if empty
+        // Create text content
+        const textContent = content === 'string' ? content : 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;
+    }
+    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 = JSON.parse(body);
+                return new FileResponse({ body: data });
+            }
+        }), filter(isNotNil));
+    }
+}
+//# 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=

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

@@ -0,0 +1,6 @@
+export function isFocusableElement(object) {
+    if (!object)
+        return false;
+    return 'focus' in object;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXNhYmxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9zaGFyZWQvZm9jdXNhYmxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE1BQU0sVUFBVSxrQkFBa0IsQ0FBQyxNQUFXO0lBQzVDLElBQUksQ0FBQyxNQUFNO1FBQUUsT0FBTyxLQUFLLENBQUM7SUFDMUIsT0FBTyxPQUFPLElBQUksTUFBTSxDQUFDO0FBQzNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIEZvY3VzYWJsZUVsZW1lbnQge1xuICBmb2N1cygpO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gaXNGb2N1c2FibGVFbGVtZW50KG9iamVjdDogYW55KTogb2JqZWN0IGlzIEZvY3VzYWJsZUVsZW1lbnQge1xuICBpZiAoIW9iamVjdCkgcmV0dXJuIGZhbHNlO1xuICByZXR1cm4gJ2ZvY3VzJyBpbiBvYmplY3Q7XG59XG5cblxuIl19