ngx-material-entity 15.1.3 → 15.1.4

package/esm2020/utilities/file.utilities.mjs

@@ -0,0 +1,163 @@
+import { LodashUtilities } from '../encapsulation/lodash.utilities';
+import { JSZipUtilities } from '../encapsulation/jszip.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.
+     * @returns A promise of the File.
+     */
+    static async getFileFromUrl(url) {
+        const res = await fetch(url);
+        if (!res.ok) {
+            // TODO make error more robust
+            throw new Error(`Error fetching the file from the url ${url}`);
+        }
+        return await res.blob();
+    }
+    // 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.
+     * @returns FileDataWithFile.
+     */
+    static async getFileData(data) {
+        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),
+                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) {
+        const a = document.createElement('a');
+        const objectUrl = URL.createObjectURL(fileData.file);
+        a.href = objectUrl;
+        a.download = fileData.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.
+     */
+    static async downloadMultipleFiles(name, multiFileData) {
+        const zip = JSZipUtilities.new();
+        for (let i = 0; i < multiFileData.length; i++) {
+            multiFileData[i] = await FileUtilities.getFileData(multiFileData[i]);
+            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 { LodashUtilities } from '../encapsulation/lodash.utilities';\nimport { FileDataWithFile } from '../decorators/file/file-decorator-internal.data';\nimport { FileData } from '../decorators/file/file-decorator.data';\nimport { JSZipUtilities } from '../encapsulation/jszip.utilities';\nimport JSZip from 'jszip';\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     * @returns A promise of the File.\n     */\n    private static async getFileFromUrl(url: string): Promise<Blob> {\n        const res: Response = await fetch(url);\n        if (!res.ok) {\n            // TODO make error more robust\n            throw new Error(`Error fetching the file from the url ${url}`);\n        }\n        return await res.blob();\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     * @returns FileDataWithFile.\n     */\n    static async getFileData(data: FileData): 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),\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        const a: HTMLAnchorElement = document.createElement('a');\n        const objectUrl: string = URL.createObjectURL(fileData.file);\n        a.href = objectUrl;\n        a.download = fileData.name;\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     */\n    static async downloadMultipleFiles(name: string, multiFileData: FileData[]): Promise<void> {\n        const zip: JSZip = JSZipUtilities.new();\n        for (let i: number = 0; i < multiFileData.length; i++) {\n            multiFileData[i] = await FileUtilities.getFileData(multiFileData[i]);\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}"]}

package/esm2020/utilities/selection.utilities.mjs

@@ -0,0 +1,50 @@
+/**
+ * Provides functionality around material selections inside of tables.
+ */
+export class SelectionUtilities {
+    /**
+     * Checks if all items in the table have been selected.
+     * This is needed to display the "masterToggle"-checkbox correctly.
+     *
+     * @param selection - The selection to check.
+     * @param dataSource - The dataSource of the selection.
+     * @returns Whether or not all items in the table have been selected.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static isAllSelected(selection, dataSource) {
+        const numSelected = selection.selected.length;
+        const numRows = dataSource.data.length;
+        return numSelected === numRows;
+    }
+    /**
+     * Toggles all items in the table.
+     *
+     * @param selection - The selection to toggle.
+     * @param dataSource - The dataSource of the selection.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static masterToggle(selection, dataSource) {
+        if (SelectionUtilities.isAllSelected(selection, dataSource)) {
+            selection.clear();
+        }
+        else {
+            dataSource.data.forEach(row => selection.select(row));
+        }
+    }
+    /**
+     * Removes all selected entries from the array.
+     *
+     * @param selection - The selection containing the items to remove.
+     * @param values - The values of the dataSource.
+     * @param dataSource - The dataSource.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static remove(selection, values, dataSource) {
+        selection.selected.forEach(s => {
+            values.splice(values.indexOf(s), 1);
+        });
+        dataSource.data = values;
+        selection.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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