ngx-material-entity 15.3.0 → 16.0.0

package/esm2022/utilities/file.utilities.mjs

@@ -0,0 +1,180 @@
+import { firstValueFrom } from 'rxjs';
+import { JSZipUtilities } from '../encapsulation/jszip.utilities';
+import { LodashUtilities } from '../encapsulation/lodash.utilities';
+/**
+ * Provides functionality regarding files.
+ */
+export class FileUtilities {
+    /**
+     * Gets the accept value for the html input.
+     *
+     * @param mimeTypes - The mimeTypes to get the accept string from.
+     * @returns A comma separated string of all the provided mime types.
+     */
+    static getAcceptString(mimeTypes) {
+        if (!mimeTypes?.length) {
+            return '*';
+        }
+        return mimeTypes.join(', ');
+    }
+    // TODO: Find a way to use blobs with jest
+    /* istanbul ignore next */
+    /**
+     * Reads a url to display the given file.
+     *
+     * @param file - The file to get the url from.
+     * @returns A promise of the url. Undefined if no file was provided.
+     */
+    static async getDataURLFromFile(file) {
+        if (!file) {
+            return undefined;
+        }
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = e => resolve(e.target?.result);
+            reader.onerror = e => reject(e);
+            reader.readAsDataURL(file);
+        });
+    }
+    // TODO: Find a way to use blobs with jest
+    /* istanbul ignore next */
+    /**
+     * Gets a file from the given url.
+     *
+     * @param url - The url to get the file from.
+     * @param http - The angular HttpClient. Used to fetch files.
+     * @returns A promise of the File.
+     */
+    static async getFileFromUrl(url, http) {
+        try {
+            return await firstValueFrom(http.get(url, { responseType: 'blob' }));
+        }
+        catch (error) {
+            throw new Error(`Error fetching the file from the url ${url}:\n ${error}`);
+        }
+    }
+    // TODO: Find a way to use blobs with jest
+    /* istanbul ignore next */
+    /**
+     * Gets the file data with the blob from the given File Data.
+     *
+     * @param data - The File Data to get the file data with blob from.
+     * @param http - The angular HttpClient. Used to fetch files.
+     * @returns FileDataWithFile.
+     */
+    static async getFileData(data, http) {
+        if (data.file) {
+            return {
+                file: data.file,
+                name: data.name,
+                url: data.url,
+                type: data.type,
+                size: data.size
+            };
+        }
+        else {
+            return {
+                file: await FileUtilities.getFileFromUrl(data.url, http),
+                name: data.name,
+                url: data.url,
+                type: data.type,
+                size: data.size
+            };
+        }
+    }
+    // TODO: Find a way to use blobs with jest
+    /* istanbul ignore next */
+    /**
+     * Downloads a single file from the given File Data.
+     *
+     * @param fileData - The file data. Needs to contain a blob.
+     */
+    static downloadSingleFile(fileData) {
+        this.downLoadBlob(fileData.file, fileData.name);
+    }
+    // TODO: Find a way to use blobs with jest
+    /* istanbul ignore next */
+    /**
+     * Downloads a blob.
+     *
+     * @param blob - The blob to download.
+     * @param name - The name of the downloaded file.
+     */
+    static downLoadBlob(blob, name) {
+        const a = document.createElement('a');
+        const objectUrl = URL.createObjectURL(blob);
+        a.href = objectUrl;
+        if (name) {
+            a.download = name;
+        }
+        a.click();
+        URL.revokeObjectURL(objectUrl);
+    }
+    // TODO: Find a way to use blobs with jest
+    /* istanbul ignore next */
+    /**
+     * Downloads multiple files as a zip with the given name.
+     *
+     * @param name - The name of the zip file to generate.
+     * @param multiFileData - The file data array to put in the zip.
+     * @param http - The angular HttpClient. Used to fetch files.
+     */
+    static async downloadMultipleFiles(name, multiFileData, http) {
+        const zip = JSZipUtilities.new();
+        for (let i = 0; i < multiFileData.length; i++) {
+            multiFileData[i] = await FileUtilities.getFileData(multiFileData[i], http);
+            zip.file(multiFileData[i].name, multiFileData[i].file);
+        }
+        const zipBlob = await zip.generateAsync({ type: 'blob' });
+        const fileData = {
+            name: name,
+            file: zipBlob,
+            type: 'application/zip',
+            size: zipBlob.size
+        };
+        FileUtilities.downloadSingleFile(fileData);
+    }
+    /**
+     * Checks if the given file has a valid mime type.
+     *
+     * @param type - The type of the file to check.
+     * @param allowedMimeTypes - The allowed mime types.
+     * @returns Whether or not the given file has a valid mime type.
+     */
+    static isMimeTypeValid(type, allowedMimeTypes) {
+        if (allowedMimeTypes.includes('*')) {
+            return true;
+        }
+        for (const t of allowedMimeTypes) {
+            if (t === type) {
+                return true;
+            }
+            if (t.endsWith('*') && type.startsWith(t.split('*')[0])) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Transform the given value to Megabytes.
+     *
+     * @param value - The original value.
+     * @param unit - If the value is B, KB or GB.
+     * @returns The given value as bytes.
+     */
+    static transformToMegaBytes(value, unit) {
+        const bytes = this.transformToBytes(LodashUtilities.cloneDeep(value), unit);
+        return bytes / 1000000;
+    }
+    static transformToBytes(value, unit) {
+        switch (unit) {
+            case 'B':
+                return value;
+            case 'KB':
+                return value * 1000;
+            case 'GB':
+                return value * 1000000000;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file.utilities.js","sourceRoot":"","sources":["../../../../projects/ngx-material-entity/src/utilities/file.utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { firstValueFrom } from 'rxjs';\nimport { FileDataWithFile } from '../decorators/file/file-decorator-internal.data';\nimport { FileData } from '../decorators/file/file-decorator.data';\nimport { JSZipUtilities, Zip } from '../encapsulation/jszip.utilities';\nimport { LodashUtilities } from '../encapsulation/lodash.utilities';\n\n/**\n * Provides functionality regarding files.\n */\nexport abstract class FileUtilities {\n    /**\n     * Gets the accept value for the html input.\n     *\n     * @param mimeTypes - The mimeTypes to get the accept string from.\n     * @returns A comma separated string of all the provided mime types.\n     */\n    static getAcceptString(mimeTypes?: string[]): string {\n        if (!mimeTypes?.length) {\n            return '*';\n        }\n        return mimeTypes.join(', ');\n    }\n\n    // TODO: Find a way to use blobs with jest\n    /* istanbul ignore next */\n    /**\n     * Reads a url to display the given file.\n     *\n     * @param file - The file to get the url from.\n     * @returns A promise of the url. Undefined if no file was provided.\n     */\n    static async getDataURLFromFile(file?: Blob): Promise<string | undefined> {\n        if (!file) {\n            return undefined;\n        }\n        return new Promise<string>((resolve, reject) => {\n            const reader: FileReader = new FileReader();\n            reader.onload = e => resolve(e.target?.result as string);\n            reader.onerror = e => reject(e);\n            reader.readAsDataURL(file);\n        });\n    }\n\n    // TODO: Find a way to use blobs with jest\n    /* istanbul ignore next */\n    /**\n     * Gets a file from the given url.\n     *\n     * @param url - The url to get the file from.\n     * @param http - The angular HttpClient. Used to fetch files.\n     * @returns A promise of the File.\n     */\n    private static async getFileFromUrl(url: string, http: HttpClient): Promise<Blob> {\n        try {\n            return await firstValueFrom(http.get(url, { responseType: 'blob' }));\n        }\n        catch (error) {\n            throw new Error(`Error fetching the file from the url ${url}:\\n ${error}`);\n        }\n    }\n\n    // TODO: Find a way to use blobs with jest\n    /* istanbul ignore next */\n    /**\n     * Gets the file data with the blob from the given File Data.\n     *\n     * @param data - The File Data to get the file data with blob from.\n     * @param http - The angular HttpClient. Used to fetch files.\n     * @returns FileDataWithFile.\n     */\n    static async getFileData(data: FileData, http: HttpClient): Promise<FileDataWithFile> {\n        if (data.file) {\n            return {\n                file: data.file,\n                name: data.name,\n                url: data.url,\n                type: data.type,\n                size: data.size\n            };\n        }\n        else {\n            return {\n                file: await FileUtilities.getFileFromUrl(data.url as string, http),\n                name: data.name,\n                url: data.url,\n                type: data.type,\n                size: data.size\n            };\n        }\n    }\n\n    // TODO: Find a way to use blobs with jest\n    /* istanbul ignore next */\n    /**\n     * Downloads a single file from the given File Data.\n     *\n     * @param fileData - The file data. Needs to contain a blob.\n     */\n    static downloadSingleFile(fileData: FileDataWithFile): void {\n        this.downLoadBlob(fileData.file, fileData.name);\n    }\n\n    // TODO: Find a way to use blobs with jest\n    /* istanbul ignore next */\n    /**\n     * Downloads a blob.\n     *\n     * @param blob - The blob to download.\n     * @param name - The name of the downloaded file.\n     */\n    static downLoadBlob(blob: Blob, name?: string): void {\n        const a: HTMLAnchorElement = document.createElement('a');\n        const objectUrl: string = URL.createObjectURL(blob);\n        a.href = objectUrl;\n        if (name) {\n            a.download = name;\n        }\n        a.click();\n        URL.revokeObjectURL(objectUrl);\n    }\n\n    // TODO: Find a way to use blobs with jest\n    /* istanbul ignore next */\n    /**\n     * Downloads multiple files as a zip with the given name.\n     *\n     * @param name - The name of the zip file to generate.\n     * @param multiFileData - The file data array to put in the zip.\n     * @param http - The angular HttpClient. Used to fetch files.\n     */\n    static async downloadMultipleFiles(name: string, multiFileData: FileData[], http: HttpClient): Promise<void> {\n        const zip: Zip = JSZipUtilities.new();\n        for (let i: number = 0; i < multiFileData.length; i++) {\n            multiFileData[i] = await FileUtilities.getFileData(multiFileData[i], http);\n            zip.file(multiFileData[i].name, (multiFileData[i] as FileDataWithFile).file);\n        }\n        const zipBlob: Blob = await zip.generateAsync({ type: 'blob' });\n        const fileData: FileDataWithFile = {\n            name: name,\n            file: zipBlob,\n            type: 'application/zip',\n            size: zipBlob.size\n        };\n        FileUtilities.downloadSingleFile(fileData);\n    }\n\n    /**\n     * Checks if the given file has a valid mime type.\n     *\n     * @param type - The type of the file to check.\n     * @param allowedMimeTypes - The allowed mime types.\n     * @returns Whether or not the given file has a valid mime type.\n     */\n    static isMimeTypeValid(type: string, allowedMimeTypes: string[]): boolean {\n        if (allowedMimeTypes.includes('*')) {\n            return true;\n        }\n        for (const t of allowedMimeTypes) {\n            if (t === type) {\n                return true;\n            }\n            if (t.endsWith('*') && type.startsWith(t.split('*')[0])) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n    /**\n     * Transform the given value to Megabytes.\n     *\n     * @param value - The original value.\n     * @param unit - If the value is B, KB or GB.\n     * @returns The given value as bytes.\n     */\n    static transformToMegaBytes(value: number, unit: 'B' | 'KB' | 'GB'): number {\n        const bytes: number = this.transformToBytes(LodashUtilities.cloneDeep(value), unit);\n        return bytes / 1000000;\n    }\n\n    private static transformToBytes(value: number, unit: 'B' | 'KB' | 'GB'): number {\n        switch (unit) {\n            case 'B':\n                return value;\n            case 'KB':\n                return value * 1000;\n            case 'GB':\n                return value * 1000000000;\n        }\n    }\n}"]}