@exmg/exm-upload 1.0.0

package/src/types.d.ts

@@ -0,0 +1,33 @@
+export interface FileData {
+    id: string;
+    url?: string;
+    file: File;
+    invalid: boolean;
+    error: string;
+    status: FileUploadState;
+    progress?: number;
+}
+export type FileUploadState = 'UPLOADING' | 'UPLOADED' | 'INVALID' | 'WARNING';
+export declare enum FileUploadError {
+    INVALID_SIZE = "File size too large",
+    INVALID_TYPE = "Invalid file type",
+    INVALID_AMOUNT = "Max amount of files exceeded",
+    INVALID_MULTIPLE = "Multiple files not allowed",
+    INVALID_RESOLUTION = "Image resulution is not valid",
+    SERVER_ERROR = "Server error occured"
+}
+export interface FileUploadConfig {
+    uploadUrl: string;
+    formUpload?: boolean;
+}
+declare global {
+    interface Window {
+        uploadDefaults: {
+            customAdapterPath?: string;
+            uploadUrl?: string;
+            headers?: {
+                [key: string]: string;
+            };
+        };
+    }
+}

package/src/types.js

@@ -0,0 +1,10 @@
+export var FileUploadError;
+(function (FileUploadError) {
+    FileUploadError["INVALID_SIZE"] = "File size too large";
+    FileUploadError["INVALID_TYPE"] = "Invalid file type";
+    FileUploadError["INVALID_AMOUNT"] = "Max amount of files exceeded";
+    FileUploadError["INVALID_MULTIPLE"] = "Multiple files not allowed";
+    FileUploadError["INVALID_RESOLUTION"] = "Image resulution is not valid";
+    FileUploadError["SERVER_ERROR"] = "Server error occured";
+})(FileUploadError = FileUploadError || (FileUploadError = {}));
+//# sourceMappingURL=types.js.map

package/src/upload/adapters/local-adapter.d.ts

@@ -0,0 +1,6 @@
+import { UploadAdapter } from '../types.js';
+declare class LocalStorageUploadAdapter implements UploadAdapter {
+    private readFileAsDataURL;
+    upload(file: File, progressCallback: (progress: number) => void): Promise<string>;
+}
+export { LocalStorageUploadAdapter as UploadAdapter };

package/src/upload/adapters/local-adapter.js

@@ -0,0 +1,23 @@
+class LocalStorageUploadAdapter {
+    async readFileAsDataURL(file) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = () => {
+                resolve(reader.result);
+            };
+            reader.onerror = () => {
+                reject(reader.error);
+            };
+            reader.readAsDataURL(file);
+        });
+    }
+    async upload(file, progressCallback) {
+        progressCallback(0);
+        const fileDataUrl = await this.readFileAsDataURL(file);
+        localStorage.setItem(file.name, fileDataUrl);
+        progressCallback(100);
+        return file.name;
+    }
+}
+export { LocalStorageUploadAdapter as UploadAdapter };
+//# sourceMappingURL=local-adapter.js.map

package/src/upload/adapters/xhr-adapter.d.ts

@@ -0,0 +1,9 @@
+import { UploadAdapter, UploadConfig } from '../types.js';
+declare class XHRUploadAdapter implements UploadAdapter {
+    config: UploadConfig;
+    xhr: XMLHttpRequest;
+    constructor(config: UploadConfig);
+    abort(): void;
+    upload(file: File, progressCallback: (progress: number) => void): Promise<string>;
+}
+export { XHRUploadAdapter as UploadAdapter };

package/src/upload/adapters/xhr-adapter.js

@@ -0,0 +1,49 @@
+class XHRUploadAdapter {
+    constructor(config) {
+        this.config = config;
+        this.xhr = new XMLHttpRequest();
+    }
+    abort() {
+        this.xhr.abort();
+    }
+    async upload(file, progressCallback) {
+        const onProgress = (event) => {
+            if (event.lengthComputable) {
+                const percentage = (event.loaded / event.total) * 100;
+                progressCallback(Math.round(percentage));
+            }
+        };
+        const { xhr } = this;
+        xhr.upload.addEventListener('progress', onProgress);
+        const formData = new FormData();
+        formData.append('filename', file.name);
+        formData.append('file', file);
+        return new Promise((resolve, reject) => {
+            const { uploadUrl } = this.config;
+            if (!uploadUrl)
+                reject(new Error(`Upload url not found`));
+            xhr.open('POST', uploadUrl, true);
+            for (const key in this.config.headers || {}) {
+                if (Object.prototype.hasOwnProperty.call(this.config.headers, key)) {
+                    xhr.setRequestHeader(key, this.config.headers[key]);
+                }
+            }
+            xhr.onreadystatechange = () => {
+                if (xhr.readyState === XMLHttpRequest.DONE) {
+                    if (xhr.status >= 200 && xhr.status < 300) {
+                        resolve(xhr.responseText);
+                    }
+                    else {
+                        reject(new Error(`Upload failed with status ${xhr.status}`));
+                    }
+                }
+            };
+            xhr.onerror = () => {
+                reject(new Error('Upload failed due to network error'));
+            };
+            xhr.send(formData);
+        });
+    }
+}
+export { XHRUploadAdapter as UploadAdapter };
+//# sourceMappingURL=xhr-adapter.js.map

package/src/upload/index.d.ts

@@ -0,0 +1 @@
+export { UploadService } from './service.js';

package/src/upload/index.js

@@ -0,0 +1,2 @@
+export { UploadService } from './service.js';
+//# sourceMappingURL=index.js.map

package/src/upload/service.d.ts

@@ -0,0 +1,9 @@
+import { UploadAdapter, UploadConfig } from './types.js';
+declare class UploadService {
+    private adapter;
+    constructor(adapter: UploadAdapter);
+    upload(file: File, progressCallback: (progress: number) => void): Promise<string>;
+    abort(): void;
+    static create(destination: 'xhr' | 'local' | 'custom', config?: UploadConfig): Promise<UploadService>;
+}
+export { UploadService };

package/src/upload/service.js

@@ -0,0 +1,42 @@
+async function instantiateClass(path, config) {
+    if (!path) {
+        throw new Error(`Class UploadAdapter path not set.`);
+    }
+    const { UploadAdapter } = await import(path);
+    if (typeof UploadAdapter === 'function') {
+        return new UploadAdapter(config);
+    }
+    else {
+        throw new Error(`Class UploadAdapter not found.`);
+    }
+}
+class UploadService {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    async upload(file, progressCallback) {
+        return this.adapter.upload(file, progressCallback);
+    }
+    abort() {
+        this.adapter.abort && this.adapter.abort();
+    }
+    static async create(destination, config) {
+        let adapter;
+        switch (destination) {
+            case 'local':
+                adapter = await instantiateClass('./adapters/local-adapter.js', config);
+                break;
+            case 'xhr':
+                adapter = await instantiateClass('./adapters/xhr-adapter.js', config);
+                break;
+            case 'custom':
+                adapter = await instantiateClass(config === null || config === void 0 ? void 0 : config.customAdapterPath, config);
+                break;
+            default:
+                throw new Error(`Unknown upload destination: ${destination}`);
+        }
+        return new UploadService(adapter);
+    }
+}
+export { UploadService };
+//# sourceMappingURL=service.js.map

package/src/upload/types.d.ts

@@ -0,0 +1,12 @@
+export interface UploadAdapter {
+    upload(file: File, progressCallback: (progress: number) => void): Promise<string>;
+    abort?: () => void;
+}
+export interface UploadConfig {
+    uploadUrl?: string;
+    customAdapterPath?: string;
+    headers?: {
+        [key: string]: string;
+    };
+    responseType?: '' | 'json' | 'text' | 'blob' | 'arraybuffer';
+}

package/src/upload/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/src/utils.d.ts

@@ -0,0 +1,33 @@
+export declare const isMimeType: (value: string) => boolean;
+/**
+ * Checks if the type of a file is valid based on the accepted types.
+ *
+ * @param file - The file object to check.
+ * @param accept - A comma-separated list of accepted types.
+ * @returns True if the file type is valid, false otherwise.
+ */
+export declare const isTypeValidExtension: (file: File, accept: string) => boolean | "" | undefined;
+/**
+ * Checks if the size of a file is valid based on the maximum size.
+ *
+ * @param size - The size of the file in bytes.
+ * @param maxSize - The maximum size allowed, with a digital unit (e.g., "10MB").
+ * @returns True if the file size is valid, false otherwise.
+ * @throws Error if the maximum size is invalid.
+ */
+export declare const isSizeValid: (size: number, maxSize: string) => boolean;
+/**
+ * Formats a byte size into a human-readable string.
+ *
+ * @param bytes - The size in bytes to format.
+ * @returns The formatted size string.
+ */
+export declare const formatBytes: (bytes: number) => string;
+/**
+ * Checks if a file is an image based on its type.
+ *
+ * @param file - The file object to check.
+ * @returns True if the file is an image, false otherwise.
+ */
+export declare const isImage: (file: File) => boolean | undefined;
+export declare const isCorrectResolution: (image: File, resolution: string) => Promise<unknown>;

package/src/utils.js

@@ -0,0 +1,89 @@
+export const isMimeType = (value) => {
+    const mimeTypeRegex = /^[a-zA-Z]+\/[a-zA-Z0-9+\-.]+(\*?)$/;
+    return mimeTypeRegex.test(value);
+};
+/**
+ * Checks if the type of a file is valid based on the accepted types.
+ *
+ * @param file - The file object to check.
+ * @param accept - A comma-separated list of accepted types.
+ * @returns True if the file type is valid, false otherwise.
+ */
+export const isTypeValidExtension = (file, accept) => {
+    var _a;
+    if (accept.trim() === '')
+        return true;
+    const acceptedTypes = new Set(accept.split(','));
+    const fileExtensionRegExp = /\.[^.]+$/;
+    const name = file.name;
+    const type = file.type;
+    const hasFileExtension = fileExtensionRegExp.test(name);
+    const [fileExtension] = !hasFileExtension ? [undefined] : (_a = fileExtensionRegExp.exec(name)) !== null && _a !== void 0 ? _a : [];
+    return acceptedTypes.has(type) || (fileExtension && acceptedTypes.has(fileExtension));
+};
+/**
+ * Checks if the size of a file is valid based on the maximum size.
+ *
+ * @param size - The size of the file in bytes.
+ * @param maxSize - The maximum size allowed, with a digital unit (e.g., "10MB").
+ * @returns True if the file size is valid, false otherwise.
+ * @throws Error if the maximum size is invalid.
+ */
+export const isSizeValid = (size, maxSize) => {
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    // Extract the size from the digital unit
+    const extracted = maxSize.split(/^([\d.]+)\s*(b|kb|mb|gb)$/i).filter((x) => x);
+    if (!extracted) {
+        throw new Error('Invalid max size set');
+    }
+    const power = sizes.indexOf(extracted[1].toUpperCase());
+    return +extracted[0] * Math.pow(1024, power) > size;
+};
+/**
+ * Formats a byte size into a human-readable string.
+ *
+ * @param bytes - The size in bytes to format.
+ * @returns The formatted size string.
+ */
+export const formatBytes = (bytes) => {
+    if (!bytes)
+        return '0 Bytes';
+    const k = 1024;
+    const dm = 2;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+};
+/**
+ * Checks if a file is an image based on its type.
+ *
+ * @param file - The file object to check.
+ * @returns True if the file is an image, false otherwise.
+ */
+export const isImage = (file) => {
+    if (!file) {
+        return;
+    }
+    return file.type.startsWith('image');
+};
+export const isCorrectResolution = (image, resolution) => {
+    if (resolution.split('x').length !== 2) {
+        throw new Error('Incorrect fixed resultion format, should be formatted like "600x400"');
+    }
+    const [width, height] = resolution.split('x');
+    const img = new Image();
+    return new Promise((resolve, reject) => {
+        img.onload = () => {
+            const correct = img.naturalWidth === parseInt(width, 10) && img.naturalHeight === parseInt(height, 10);
+            resolve(correct);
+            URL.revokeObjectURL(img.src);
+        };
+        const objectURL = URL.createObjectURL(image);
+        img.src = objectURL;
+        img.onerror = () => {
+            URL.revokeObjectURL(img.src);
+            reject(new Error('Error reading aspect ratio'));
+        };
+    });
+};
+//# sourceMappingURL=utils.js.map