@wlindabla/file_uploader 1.0.0 → 2.0.0

package/dist/esm/chunk-NXYS73I4.js

@@ -0,0 +1,125 @@
+import { __name } from './chunk-7QVYU63E.js';
+
+// src/exceptions/index.ts
+var InitializeUploadFailureException = class _InitializeUploadFailureException extends Error {
+  constructor(responseData, message) {
+    super(message);
+    this.responseData = responseData;
+    this.name = "InitializeUploadFailureException";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _InitializeUploadFailureException);
+    }
+  }
+  responseData;
+  static {
+    __name(this, "InitializeUploadFailureException");
+  }
+};
+var ChunkUploadHttpErrorException = class _ChunkUploadHttpErrorException extends Error {
+  constructor(errorPayload, statusResponse) {
+    super();
+    this.errorPayload = errorPayload;
+    this.statusResponse = statusResponse;
+    this.name = "ChunkUploadHttpErrorException";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _ChunkUploadHttpErrorException);
+    }
+  }
+  errorPayload;
+  statusResponse;
+  static {
+    __name(this, "ChunkUploadHttpErrorException");
+  }
+};
+var FileUploadChunkError = class _FileUploadChunkError extends Error {
+  static {
+    __name(this, "FileUploadChunkError");
+  }
+  /**
+   * The detailed chunk error information
+   */
+  chunkError;
+  /**
+   * Creates a new FileUploadChunkError
+   * 
+   * @param message - Human-readable error message
+   * @param chunkError - Detailed information about the chunk failure
+   */
+  constructor(message, chunkError) {
+    super(message, { cause: chunkError.error });
+    this.name = "FileUploadChunkError";
+    this.chunkError = chunkError;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _FileUploadChunkError);
+    }
+  }
+  /**
+   * Gets the index of the chunk that failed
+   */
+  get chunkIndex() {
+    return this.chunkError.chunk.index;
+  }
+  /**
+   * Gets the attempt number when the chunk failed
+   */
+  get attemptNumber() {
+    return this.chunkError.attempt;
+  }
+  /**
+   * Indicates whether a retry will be attempted
+   */
+  get willRetry() {
+    return this.chunkError.willRetry;
+  }
+  /**
+   * Gets the underlying error that caused the chunk upload to fail
+   */
+  get underlyingError() {
+    return this.chunkError.error;
+  }
+  /**
+   * Gets the full chunk information
+   */
+  get chunk() {
+    return this.chunkError.chunk;
+  }
+  /**
+   * Returns a JSON representation of the error
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      chunkIndex: this.chunkIndex,
+      attempt: this.attemptNumber,
+      willRetry: this.willRetry,
+      underlyingError: {
+        name: this.underlyingError.name,
+        message: this.underlyingError.message
+      },
+      stack: this.stack
+    };
+  }
+};
+var UploadCancelledException = class _UploadCancelledException extends Error {
+  constructor(chunkIndex, totalChunks, uploadedBytes, message) {
+    super(message);
+    this.chunkIndex = chunkIndex;
+    this.totalChunks = totalChunks;
+    this.uploadedBytes = uploadedBytes;
+    this.name = "UploadCancelledException";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _UploadCancelledException);
+    }
+  }
+  chunkIndex;
+  totalChunks;
+  uploadedBytes;
+  static {
+    __name(this, "UploadCancelledException");
+  }
+};
+
+export { ChunkUploadHttpErrorException, FileUploadChunkError, InitializeUploadFailureException, UploadCancelledException };
+//# sourceMappingURL=chunk-NXYS73I4.js.map
+//# sourceMappingURL=chunk-NXYS73I4.js.map

package/dist/esm/chunk-NXYS73I4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/exceptions/index.ts"],"names":[],"mappings":"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","file":"chunk-NXYS73I4.js","sourcesContent":["/*\n * This file is part of the project by AGBOKOUDJO Franck.\n *\n * (c) AGBOKOUDJO Franck <internationaleswebservices@gmail.com>\n * Phone: +229 0167 25 18 86\n * LinkedIn: https://www.linkedin.com/in/internationales-web-apps-services-120520193/\n * Company: INTERNATIONALES WEB APPS & SERVICES\n *\n * For more information, please feel free to contact the author.\n */\n\nimport { ChunkInfo, ChunkError } from \"../types\";\n\nexport class InitializeUploadFailureException extends Error {\n    constructor(public readonly responseData: any, message: string) {\n        super(message);\n        this.name = \"InitializeUploadFailureException\";\n\n        if (Error.captureStackTrace) {\n            Error.captureStackTrace(this, InitializeUploadFailureException);\n        }\n    }\n}\n\n/**\n * Exception data for MEDIA_CHUNK_UPLOAD_HTTP_ERROR_RESPONSE\n */\nexport class ChunkUploadHttpErrorException extends Error {\n    constructor(\n        public readonly errorPayload: string | Record<string, string | unknown> | unknown,\n        public readonly statusResponse: number\n    ) {\n        super();\n\n        this.name = \"ChunkUploadHttpErrorException\";\n\n        if (Error.captureStackTrace) {\n            Error.captureStackTrace(this, ChunkUploadHttpErrorException);\n        }\n    }\n}\n\n/**\n * Custom error thrown during chunked file upload operations.\n * \n * This error provides detailed information about which chunk failed,\n * the underlying error, and whether a retry will be attempted.\n * \n * @example\n * ```typescript\n * try {\n *   await uploadChunk(chunk);\n * } catch (error) {\n *   throw new FileUploadChunkError(\n *     `Failed to upload chunk ${chunkIndex}`,\n *     chunkError\n *   );\n * }\n * \n * // Later in error handler\n * if (error instanceof FileUploadChunkError) {\n *   console.log(`Chunk ${error.chunkIndex} failed`);\n *   console.log(`Will retry: ${error.willRetry}`);\n * }\n * ```\n */\nexport class FileUploadChunkError extends Error {\n\n    /**\n     * The detailed chunk error information\n     */\n    public readonly chunkError: ChunkError;\n\n    /**\n     * Creates a new FileUploadChunkError\n     * \n     * @param message - Human-readable error message\n     * @param chunkError - Detailed information about the chunk failure\n     */\n    constructor(message: string, chunkError: ChunkError) {\n        super(message, { cause: chunkError.error });\n\n        this.name = \"FileUploadChunkError\";\n        this.chunkError = chunkError;\n\n        // Maintain proper stack trace in V8 engines (Chrome, Node.js)\n        if (Error.captureStackTrace) {\n            Error.captureStackTrace(this, FileUploadChunkError);\n        }\n    }\n\n    /**\n     * Gets the index of the chunk that failed\n     */\n    get chunkIndex(): number {\n        return this.chunkError.chunk.index;\n    }\n\n    /**\n     * Gets the attempt number when the chunk failed\n     */\n    get attemptNumber(): number {\n        return this.chunkError.attempt;\n    }\n\n    /**\n     * Indicates whether a retry will be attempted\n     */\n    get willRetry(): boolean {\n        return this.chunkError.willRetry;\n    }\n\n    /**\n     * Gets the underlying error that caused the chunk upload to fail\n     */\n    get underlyingError(): Error {\n        return this.chunkError.error;\n    }\n\n    /**\n     * Gets the full chunk information\n     */\n    get chunk(): ChunkInfo {\n        return this.chunkError.chunk;\n    }\n    \n    /**\n     * Returns a JSON representation of the error\n     */\n    toJSON(): object {\n        return {\n            name: this.name,\n            message: this.message,\n            chunkIndex: this.chunkIndex,\n            attempt: this.attemptNumber,\n            willRetry: this.willRetry,\n            underlyingError: {\n                name: this.underlyingError.name,\n                message: this.underlyingError.message\n            },\n            stack: this.stack\n        };\n    }\n}\n\n\nexport class UploadCancelledException extends Error {\n    constructor(\n        public readonly chunkIndex: number,\n        public readonly totalChunks: number,\n        public readonly uploadedBytes: number,\n        message: string\n    ) {\n        super(message);\n        this.name = \"UploadCancelledException\";\n\n        if (Error.captureStackTrace) {\n            Error.captureStackTrace(this, UploadCancelledException);\n        }\n    }\n}"]}

package/dist/{cache/index.js → esm/chunk-PFALORWQ.js}

@@ -1,8 +1,7 @@
-'use strict';
+import { __name } from './chunk-7QVYU63E.js';
 
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-class DefaultUploadResumeCacheAdapter {
+// src/cache/index.ts
+var DefaultUploadResumeCacheAdapter = class {
   static {
     __name(this, "DefaultUploadResumeCacheAdapter");
   }
@@ -277,19 +276,19 @@ class DefaultUploadResumeCacheAdapter {
   get usage() {
     return this.cache.size / this.maxCacheSize * 100;
   }
-}
-class UploadCacheError extends Error {
+};
+var UploadCacheError = class extends Error {
   constructor(message, code) {
     super(message);
     this.code = code;
     this.name = "UploadCacheError";
   }
+  code;
   static {
     __name(this, "UploadCacheError");
   }
-}
+};
 
-exports.DefaultUploadResumeCacheAdapter = DefaultUploadResumeCacheAdapter;
-exports.UploadCacheError = UploadCacheError;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export { DefaultUploadResumeCacheAdapter, UploadCacheError };
+//# sourceMappingURL=chunk-PFALORWQ.js.map
+//# sourceMappingURL=chunk-PFALORWQ.js.map

package/dist/esm/chunk-PFALORWQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cache/index.ts"],"names":[],"mappings":"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","file":"chunk-PFALORWQ.js","sourcesContent":["/*\n * This file is part of the project by AGBOKOUDJO Franck.\n *\n * (c) AGBOKOUDJO Franck <internationaleswebservices@gmail.com>\n * Phone: +229 0167 25 18 86\n * LinkedIn: https://www.linkedin.com/in/internationales-web-apps-services-120520193/\n * Company: INTERNATIONALES WEB APPS & SERVICES\n *\n * For more information, please feel free to contact the author.\n */\n\nimport { ResumeData } from \"../types\"\n\n/**\n * Interface for caching upload resume data.\n * \n * This interface extends the base cache functionality to specifically\n * handle resume data for file uploads, allowing uploads to be paused\n * and resumed across browser sessions.\n * \n * \n * @example\n * ```typescript\n * const cache: UploadResumeCacheInterface = new LocalStorageUploadResumeCache();\n * \n * // Save progress\n * await cache.setItem('video.mp4', {\n *   uploadedChunks: 45,\n *   totalChunks: 100,\n *   lastBytePosition: 47185920\n * });\n * \n * // Resume later\n * const data = await cache.getItem('video.mp4');\n * console.log(`Resume from chunk ${data.uploadedChunks}`);\n * ```\n */\nexport interface UploadResumeCacheInterface {\n    /**\n     * Retrieves cached resume data for a specific upload.\n     * \n     * @param key - Unique identifier for the upload (typically filename or file hash)\n     * @returns Promise resolving to the cached resume data\n     * @throws {Error} If the key doesn't exist or data is corrupted\n     */\n    getItem(key: string): Promise<ResumeData>;\n\n    /**\n     * Stores resume data for an upload session.\n     * \n     * @param key - Unique identifier for the upload\n     * @param data - Resume data containing upload progress information\n     * @returns Promise that resolves when data is successfully cached\n     * @throws {Error} If storage quota is exceeded or data is invalid\n     */\n    setItem(key: string, data: ResumeData): Promise<void>;\n}\n\n/**\n * Default adapter for caching resume data during file uploads.\n * \n * Implements an in-memory storage strategy with secure serialization,\n * strict data validation, and comprehensive error handling.\n * \n * This implementation serves as a foundation for specialized adapters\n * (localStorage, IndexedDB, sessionStorage, etc.).\n * \n * @implements {UploadResumeCacheInterface}\n * \n * @example\n * ```typescript\n * const adapter = new DefaultUploadResumeCacheAdapter();\n * \n * // Save resume data\n * await adapter.setItem('upload-123', {\n *   fileId: 'file-abc',\n *   fileName: 'document.pdf',\n *   fileSize: 5242880,\n *   uploadedChunks: 12,\n *   lastChunkIndex: 11,\n *   lastBytePosition: 1258291,\n *   chunkSize: 1048576\n * });\n * \n * // Retrieve and resume\n * const resumeData = await adapter.getItem('upload-123');\n * console.log(`Resume from chunk ${resumeData.uploadedChunks}`);\n * \n * // Remove specific item\n * await adapter.removeItem('upload-123');\n * \n * // Clear all cache\n * await adapter.clear();\n * ```\n */\nexport class DefaultUploadResumeCacheAdapter implements UploadResumeCacheInterface {\n\n    private cache: Map<string, ResumeData> = new Map();\n    private readonly maxCacheSize: number = 100;\n\n    constructor() {\n        this.validateEnvironment();\n    }\n\n    /**\n     * Validates that the runtime environment is appropriate.\n     * \n     * @private\n     * @throws {UploadCacheError} If the environment is incompatible\n     */\n    private validateEnvironment(): void {\n        if (typeof window === 'undefined') {\n            console.warn(\n                '[UploadResumeCacheAdapter] Server-side execution detected. ' +\n                'Consider a server-compatible adapter for persistent storage.'\n            );\n        }\n    }\n\n    /**\n     * Validates resume data according to strict criteria.\n     * \n     * @private\n     * @param data - The data to validate\n     * @throws {UploadCacheError} If the data is invalid\n     */\n    private validateResumeData(data: ResumeData): void {\n        if (!data || typeof data !== 'object') {\n            throw new UploadCacheError(\n                'Resume data must be a valid object',\n                'INVALID_DATA'\n            );\n        }\n\n        // Validate required fields\n        const requiredFields: (keyof ResumeData)[] = [\n            'fileId',\n            'fileName',\n            'fileSize',\n            'uploadedChunks',\n            'lastChunkIndex',\n            'lastBytePosition',\n            'chunkSize'\n        ];\n\n        for (const field of requiredFields) {\n            if (!(field in data)) {\n                throw new UploadCacheError(\n                    `Required field '${field}' is missing`,\n                    'MISSING_FIELD'\n                );\n            }\n        }\n\n        // Validate types\n        if (typeof data.fileId !== 'string' || !data.fileId.trim()) {\n            throw new UploadCacheError(\n                'fileId must be a non-empty string',\n                'INVALID_FILE_ID'\n            );\n        }\n\n        if (typeof data.fileName !== 'string' || !data.fileName.trim()) {\n            throw new UploadCacheError(\n                'fileName must be a non-empty string',\n                'INVALID_FILE_NAME'\n            );\n        }\n\n        // Validate numbers\n        if (!Number.isFinite(data.fileSize) || data.fileSize <= 0) {\n            throw new UploadCacheError(\n                'fileSize must be a positive number',\n                'INVALID_FILE_SIZE'\n            );\n        }\n\n        if (!Number.isFinite(data.chunkSize) || data.chunkSize <= 0) {\n            throw new UploadCacheError(\n                'chunkSize must be a positive number',\n                'INVALID_CHUNK_SIZE'\n            );\n        }\n\n        if (!Number.isInteger(data.uploadedChunks) || data.uploadedChunks < 0) {\n            throw new UploadCacheError(\n                'uploadedChunks must be a non-negative integer',\n                'INVALID_UPLOADED_CHUNKS'\n            );\n        }\n\n        if (!Number.isInteger(data.lastChunkIndex) || data.lastChunkIndex < -1) {\n            throw new UploadCacheError(\n                'lastChunkIndex must be an integer >= -1',\n                'INVALID_LAST_CHUNK_INDEX'\n            );\n        }\n\n        if (!Number.isFinite(data.lastBytePosition) || data.lastBytePosition < 0) {\n            throw new UploadCacheError(\n                'lastBytePosition must be a non-negative number',\n                'INVALID_BYTE_POSITION'\n            );\n        }\n\n        // Validate logical consistency\n        if (data.uploadedChunks > 0 && data.lastBytePosition === 0) {\n            throw new UploadCacheError(\n                'lastBytePosition cannot be 0 if chunks have been uploaded',\n                'INCONSISTENT_DATA'\n            );\n        }\n\n        const expectedMaxChunks = Math.ceil(data.fileSize / data.chunkSize);\n        if (data.uploadedChunks > expectedMaxChunks) {\n            throw new UploadCacheError(\n                `uploadedChunks (${data.uploadedChunks}) exceeds maximum expected (${expectedMaxChunks})`,\n                'INCONSISTENT_DATA'\n            );\n        }\n    }\n\n    /**\n     * Retrieves resume data for a specific upload.\n     * \n     * @param key - Unique identifier for the upload\n     * @returns Promise resolved with the resume data\n     * @throws {UploadCacheError} If the key does not exist or data is corrupted\n     * \n     * @example\n     * ```typescript\n     * try {\n     *   const data = await adapter.getItem('upload-123');\n     *   console.log(`${data.uploadedChunks}/${Math.ceil(data.fileSize / data.chunkSize)} chunks`);\n     * } catch (error) {\n     *   console.error('Failed to retrieve data:', error.message);\n     * }\n     * ```\n     */\n    async getItem(key: string): Promise<ResumeData> {\n        return new Promise((resolve, reject) => {\n            try {\n                if (!key || typeof key !== 'string') {\n                    reject(new UploadCacheError(\n                        'Key must be a non-empty string',\n                        'INVALID_KEY'\n                    ));\n                    return;\n                }\n\n                const data = this.cache.get(key);\n\n                if (!data) {\n                    reject(new UploadCacheError(\n                        `Resume data for key '${key}' was not found`,\n                        'NOT_FOUND'\n                    ));\n                    return;\n                }\n\n                // Return a deep copy to prevent external mutations\n                resolve(JSON.parse(JSON.stringify(data)));\n            } catch (error) {\n                reject(new UploadCacheError(\n                    `Error retrieving data: ${error instanceof Error ? error.message : String(error)}`,\n                    'RETRIEVAL_ERROR'\n                ));\n            }\n        });\n    }\n\n    /**\n     * Stores resume data for an upload session.\n     * \n     * @param key - Unique identifier for the upload\n     * @param data - Resume data containing upload progress information\n     * @returns Promise resolved when data is successfully cached\n     * @throws {UploadCacheError} If quota is exceeded or data is invalid\n     * \n     * @example\n     * ```typescript\n     * try {\n     *   await adapter.setItem('upload-123', {\n     *     fileId: 'file-abc',\n     *     fileName: 'video.mp4',\n     *     fileSize: 10737418240,\n     *     uploadedChunks: 45,\n     *     lastChunkIndex: 44,\n     *     lastBytePosition: 47185920,\n     *     chunkSize: 1048576\n     *   });\n     *   console.log('Data successfully saved');\n     * } catch (error) {\n     *   console.error('Storage error:', error.message);\n     * }\n     * ```\n     */\n    async setItem(key: string, data: ResumeData): Promise<void> {\n        return new Promise((resolve, reject) => {\n            try {\n                if (!key || typeof key !== 'string') {\n                    reject(new UploadCacheError(\n                        'Key must be a non-empty string',\n                        'INVALID_KEY'\n                    ));\n                    return;\n                }\n\n                this.validateResumeData(data);\n\n                // Check cache limit\n                if (this.cache.size >= this.maxCacheSize && !this.cache.has(key)) {\n                    reject(new UploadCacheError(\n                        `Cache limit (${this.maxCacheSize} entries) has been reached. ` +\n                        'Remove obsolete entries or use an adapter with persistent storage.',\n                        'CACHE_LIMIT_EXCEEDED'\n                    ));\n                    return;\n                }\n\n                // Store a deep copy\n                this.cache.set(key, JSON.parse(JSON.stringify(data)));\n                resolve();\n            } catch (error) {\n                if (error instanceof UploadCacheError) {\n                    reject(error);\n                } else {\n                    reject(new UploadCacheError(\n                        `Error storing data: ${error instanceof Error ? error.message : String(error)}`,\n                        'STORAGE_ERROR'\n                    ));\n                }\n            }\n        });\n    }\n\n    /**\n     * Removes resume data for a specific upload.\n     * \n     * @param key - Unique identifier for the upload\n     * @returns Promise resolved after removal\n     * \n     * @example\n     * ```typescript\n     * await adapter.removeItem('upload-123');\n     * ```\n     */\n    async removeItem(key: string): Promise<void> {\n        return new Promise((resolve, reject) => {\n            try {\n                if (!key || typeof key !== 'string') {\n                    reject(new UploadCacheError(\n                        'Key must be a non-empty string',\n                        'INVALID_KEY'\n                    ));\n                    return;\n                }\n\n                this.cache.delete(key);\n                resolve();\n            } catch (error) {\n                reject(new UploadCacheError(\n                    `Error removing data: ${error instanceof Error ? error.message : String(error)}`,\n                    'DELETION_ERROR'\n                ));\n            }\n        });\n    }\n\n    /**\n     * Clears all cached resume data.\n     * \n     * @returns Promise resolved after complete cleanup\n     * \n     * @example\n     * ```typescript\n     * await adapter.clear();\n     * console.log('Cache cleared');\n     * ```\n     */\n    async clear(): Promise<void> {\n        return new Promise((resolve) => {\n            this.cache.clear();\n            resolve();\n        });\n    }\n\n    /**\n     * Returns the number of entries currently in cache.\n     * \n     * @returns Number of cache entries\n     */\n    get size(): number {\n        return this.cache.size;\n    }\n\n    /**\n     * Returns cache usage as a percentage.\n     * \n     * @returns Usage percentage (0-100)\n     */\n    get usage(): number {\n        return (this.cache.size / this.maxCacheSize) * 100;\n    }\n}\n\n/**\n * Custom error for upload cache operations.\n * \n * @example\n * ```typescript\n * throw new UploadCacheError('Resume data not found', 'NOT_FOUND');\n * ```\n */\nexport class UploadCacheError extends Error {\n    constructor(\n        message: string,\n        public readonly code: string\n    ) {\n        super(message);\n        this.name = 'UploadCacheError';\n    }\n}\n"]}

package/dist/{types/index.js → esm/chunk-X757PBC5.js}

@@ -1,5 +1,4 @@
-'use strict';
-
+// src/types/index.ts
 var UploadState = /* @__PURE__ */ ((UploadState2) => {
   UploadState2["IDLE"] = "idle";
   UploadState2["INITIALIZING"] = "initializing";
@@ -11,7 +10,7 @@ var UploadState = /* @__PURE__ */ ((UploadState2) => {
   UploadState2["FAILED"] = "failed";
   return UploadState2;
 })(UploadState || {});
-const DEFAULT_CONFIG = Object.freeze({
+var DEFAULT_CONFIG = Object.freeze({
   defaultChunkSizeMB: 50,
   slowSpeedThresholdMbps: 5,
   slowSpeedChunkSizeMB: 2,
@@ -24,7 +23,6 @@ const DEFAULT_CONFIG = Object.freeze({
   ]
 });
 
-exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
-exports.UploadState = UploadState;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export { DEFAULT_CONFIG, UploadState };
+//# sourceMappingURL=chunk-X757PBC5.js.map
+//# sourceMappingURL=chunk-X757PBC5.js.map

package/dist/esm/chunk-X757PBC5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/index.ts"],"names":["UploadState"],"mappings":";AAkEO,IAAK,WAAA,qBAAAA,YAAAA,KAAL;AACH,EAAAA,aAAA,MAAA,CAAA,GAAO,MAAA;AACP,EAAAA,aAAA,cAAA,CAAA,GAAe,cAAA;AACf,EAAAA,aAAA,WAAA,CAAA,GAAY,WAAA;AACZ,EAAAA,aAAA,QAAA,CAAA,GAAS,QAAA;AACT,EAAAA,aAAA,WAAA,CAAA,GAAY,WAAA;AACZ,EAAAA,aAAA,YAAA,CAAA,GAAa,YAAA;AACb,EAAAA,aAAA,WAAA,CAAA,GAAY,WAAA;AACZ,EAAAA,aAAA,QAAA,CAAA,GAAS,QAAA;AARD,EAAA,OAAAA,YAAAA;AAAA,CAAA,EAAA,WAAA,IAAA,EAAA;AAiCL,IAAM,cAAA,GAA4C,OAAO,MAAA,CAAO;AAAA,EACnE,kBAAA,EAAoB,EAAA;AAAA,EACpB,sBAAA,EAAwB,CAAA;AAAA,EACxB,oBAAA,EAAsB,CAAA;AAAA,EACtB,kBAAA,EAAoB;AAAA,IAChB,EAAE,SAAA,EAAW,GAAA,EAAK,WAAA,EAAa,EAAA,EAAG;AAAA,IAClC,EAAE,SAAA,EAAW,GAAA,EAAK,WAAA,EAAa,GAAA,EAAI;AAAA,IACnC,EAAE,SAAA,EAAW,GAAA,EAAK,WAAA,EAAa,GAAA,EAAI;AAAA,IACnC,EAAE,SAAA,EAAW,GAAA,EAAM,WAAA,EAAa,GAAA,EAAI;AAAA,IACpC,EAAE,SAAA,EAAW,QAAA,EAAU,WAAA,EAAa,GAAA;AAAI;AAEhD,CAAC","file":"chunk-X757PBC5.js","sourcesContent":["/*\n * This file is part of the project by AGBOKOUDJO Franck.\n *\n * (c) AGBOKOUDJO Franck <internationaleswebservices@gmail.com>\n * Phone: +229 0167 25 18 86\n * LinkedIn: https://www.linkedin.com/in/internationales-web-apps-services-120520193/\n * Company: INTERNATIONALES WEB APPS & SERVICES\n *\n * For more information, please feel free to contact the author.\n */\n\nimport { FetchResponseInterface } from \"@wlindabla/http_client\";\n\nexport interface UploadOptions {\n    autoSave?: boolean,\n    chunkSize?: number;\n    speedMbps?: number;\n    config?: ChunkSizeConfig;\n    headers?: HeadersInit;\n    chunkOtherData?: Record<string, any>;\n    metadata?: Record<string, any>;\n    maxRetries?: number;\n    timeout?: number;\n    initTimeout?: number;\n    headerInitialzingUpload?: HeadersInit;\n    headerFinalezingUpload?: HeadersInit;\n    concurrency?: number; // Default: 3\n}\n\nexport interface InitializeUploadOptions{\n    metadata?: Record<string, any>;\n    fileHash: string;\n    fileName: string;\n    fileSize: number;\n    fileType: string;\n    endpointInit: string | URL;\n    headers?: HeadersInit;\n}\n\nexport interface UploadEndpoints{\n    init: string | URL;\n    upload: string | URL;\n    finalize: string | URL;\n}\n\nexport interface ChunkSizeConfig {\n    defaultChunkSizeMB: number;\n    slowSpeedThresholdMbps: number;\n    slowSpeedChunkSizeMB: number;\n    fileSizeThresholds: Array<{\n        maxSizeMB: number;\n        chunkSizeMB: number;\n    }>;\n}\n\nexport type UploadStatus = 'pending' | 'uploading' | 'success' | 'error';\n\nexport interface ChunkInfo {\n    index: number;\n    start: number;\n    end: number;\n    size: number;\n    attempt: number;\n    status: UploadStatus;\n}\n\nexport enum UploadState {\n    IDLE = 'idle',\n    INITIALIZING = 'initializing',\n    UPLOADING = 'uploading',\n    PAUSED = 'paused',\n    CANCELLED = 'cancelled',\n    FINALIZING = 'finalizing',\n    COMPLETED = 'completed',\n    FAILED = 'failed'\n}\n\nexport interface UploadResult {\n    success: boolean;\n    fileId?: string;\n    totalChunks: number;\n    totalBytes: number;\n    duration: number;\n    averageSpeed: number;\n    finalizeUploadResponse?: FetchResponseInterface | null;\n    statusResponse?: number;\n}\n\nexport interface ResumeData {\n    fileId: string;\n    fileName: string;\n    fileSize: number;\n    uploadedChunks: number;\n    lastChunkIndex: number;\n    lastBytePosition: number;\n    chunkSize: number;\n    concurrency: number;\n}\n\nexport const DEFAULT_CONFIG: Readonly<ChunkSizeConfig> = Object.freeze({\n    defaultChunkSizeMB: 50,\n    slowSpeedThresholdMbps: 5,\n    slowSpeedChunkSizeMB: 2,\n    fileSizeThresholds: [\n        { maxSizeMB: 200, chunkSizeMB: 50 },\n        { maxSizeMB: 400, chunkSizeMB: 100 },\n        { maxSizeMB: 800, chunkSizeMB: 300 },\n        { maxSizeMB: 1000, chunkSizeMB: 500 },\n        { maxSizeMB: Infinity, chunkSizeMB: 700 }\n    ]\n});\n\nexport interface UploadProgress {\n    uploadedChunks: number;\n    totalChunks: number;\n    uploadedBytes: number;\n    totalBytes: number;\n    percentage: number;\n    currentChunk: number;\n    speed?: number; // bytes per second\n    estimatedTimeRemaining?: number | null; // seconds\n    elapsed: number;// secondes écoulées\n}\nexport interface ChunkError {\n    chunk: ChunkInfo;\n    error: Error;\n    attempt: number;\n    willRetry: boolean;\n}\n\n/**\n * Expected response structure from initialize endpoint\n */\nexport interface InitializeUploadResponse {\n    mediaIdFromServer?: string | number;\n    sessionId?: string | number;\n    uploadId?: string | number;\n    mediaId?: string | number;\n    message?: string | number;\n    [key: string]: any; // Allow extra fields\n}"]}

package/dist/esm/core/index.d.mts

@@ -0,0 +1,267 @@
+import { EventDispatcherInterface } from '@wlindabla/event_dispatcher';
+import { UploadOptions, UploadEndpoints, UploadState, ResumeData } from '../types/index.mjs';
+import { UploadResumeCacheInterface } from '../cache/index.mjs';
+import '@wlindabla/http_client';
+
+/**
+ * ChunkedFileUploader
+ *
+ * A production-ready, event-driven chunked file upload engine for Browser and Node.js.
+ *
+ * Designed and developed by **AGBOKOUDJO Franck** at
+ * **INTERNATIONALES WEB APPS & SERVICES**, this class provides a robust,
+ * framework-agnostic solution for uploading large files to a remote server
+ * by splitting them into smaller chunks and sending them in parallel with
+ * configurable concurrency control.
+ *
+ * ---
+ *
+ * ### How It Works
+ *
+ * The upload process follows a strict three-phase lifecycle:
+ *
+ * 1. **Initialization** — A session is opened with the server via the `init` endpoint.
+ *    The file is identified by its name, size, type, and a SHA-256 hash of its
+ *    first megabyte. The server returns a unique `mediaId` that identifies the session.
+ *
+ * 2. **Chunk Upload** — The file is sliced into fixed-size chunks and uploaded
+ *    concurrently using `p-limit`. Each chunk carries its index, the total number
+ *    of chunks, and the session `mediaId`. Failed chunks are retried automatically
+ *    with exponential backoff up to `maxRetries` attempts.
+ *
+ * 3. **Finalization** — Once all chunks are successfully uploaded, the `finalize`
+ *    endpoint is called to instruct the server to assemble the chunks into the
+ *    final file.
+ *
+ * ---
+ *
+ * ### Event-Driven Architecture
+ *
+ * This class follows the **Symfony EventDispatcher pattern** via
+ * `@wlindabla/event_dispatcher`. Every meaningful moment in the upload
+ * lifecycle emits a typed event that your application can listen to:
+ *
+ * ```
+ * IDLE → INITIALIZING → UPLOADING → FINALIZING → COMPLETED
+ *                ↓            ↓
+ *             FAILED        PAUSED ↔ UPLOADING
+ *                              ↓
+ *                          CANCELLED
+ * ```
+ *
+ * All event name constants are centralized in {@link HttpFileUploaderEvents}.
+ *
+ * ---
+ *
+ * ### Subscriber Registration (Required)
+ *
+ * Before calling `.upload()`, you **must** register the two built-in subscribers
+ * on your dispatcher. They handle the HTTP communication for the init and finalize phases:
+ *
+ * ```typescript
+ * // Browser
+ * const dispatcher = new BrowserEventDispatcher(document);
+ * dispatcher.addSubscriber(new InitializeUploadSubscriber(dispatcher));
+ * dispatcher.addSubscriber(new FinalizeUploadSubscriber(dispatcher));
+ *
+ * // Node.js
+ * const dispatcher = new NodeEventDispatcher();
+ * dispatcher.addSubscriber(new InitializeUploadSubscriber(dispatcher));
+ * dispatcher.addSubscriber(new FinalizeUploadSubscriber(dispatcher));
+ * ```
+ *
+ * ---
+ *
+ * ### Fluent Builder API
+ *
+ * The class exposes a fluent API to configure the upload before starting:
+ *
+ * ```typescript
+ * const uploader = new ChunkedFileUploader(dispatcher, cache, options);
+ *
+ * await uploader
+ *   .withFile(file)
+ *   .withEndpoints({
+ *     init:     'https://api.example.com/upload/init',
+ *     upload:   'https://api.example.com/upload/chunk',
+ *     finalize: 'https://api.example.com/upload/finalize'
+ *   })
+ *   .upload();
+ * ```
+ *
+ * ---
+ *
+ * ### Resumable Uploads
+ *
+ * When `autoSave: true` is set in options, the upload progress is persisted
+ * after each successful chunk via the {@link UploadResumeCacheInterface}.
+ * A failed or interrupted upload can be resumed later:
+ *
+ * ```typescript
+ * const resumeData = await uploader.loadResumeData(file.name);
+ *
+ * if (resumeData) {
+ *   await uploader
+ *     .withFile(file)
+ *     .withEndpoints(endpoints)
+ *     .resumeUpload(resumeData);
+ * }
+ * ```
+ *
+ * ---
+ *
+ * ### Concurrency
+ *
+ * Multiple chunks can be uploaded simultaneously. The `concurrency` option
+ * controls how many parallel uploads are active at any given time.
+ * The default value is `3`, which provides a good balance between speed
+ * and server/network load:
+ *
+ * ```typescript
+ * // Upload 5 chunks in parallel
+ * new ChunkedFileUploader(dispatcher, cache, { concurrency: 5 });
+ * ```
+ *
+ * ---
+ *
+ * ### Pause, Resume and Cancel
+ *
+ * The upload can be paused, resumed, or cancelled at any time:
+ *
+ * ```typescript
+ * uploader.pause();   // Pauses after the current chunk finishes
+ * uploader.resume();  // Resumes from where it was paused
+ * uploader.cancel();  // Aborts immediately via AbortController
+ * ```
+ *
+ * ---
+ *
+ * ### Cache
+ *
+ * The library does **not** provide a built-in cache implementation to stay
+ * lightweight and environment-agnostic. You must implement
+ * {@link UploadResumeCacheInterface} with your preferred storage backend
+ * (localStorage, IndexedDB, Redis, filesystem, etc.).
+ *
+ * ---
+ *
+ * @author    AGBOKOUDJO Franck <internationaleswebservices@gmail.com>
+ * @company   INTERNATIONALES WEB APPS & SERVICES
+ * @phone     +229 0167 25 18 86
+ * @linkedin  https://www.linkedin.com/in/internationales-web-apps-services-120520193/
+ * @github    https://github.com/Agbokoudjo/file_uploader
+ *
+ * @version   1.0.0
+ * @since     1.0.0
+ * @license   MIT
+ *
+ * @see {@link HttpFileUploaderEvents}        All event name constants
+ * @see {@link UploadResumeCacheInterface}    Cache interface to implement
+ * @see {@link InitializeUploadSubscriber}    Handles the init HTTP phase
+ * @see {@link FinalizeUploadSubscriber}      Handles the finalize HTTP phase
+ * @see {@link UploadOptions}                 Full configuration reference
+ * @see {@link https://github.com/Agbokoudjo/file_uploader | GitHub Repository}
+ */
+declare class ChunkedFileUploader {
+    private readonly _uploadEventDispatcher;
+    private readonly uploadResumeData;
+    private options;
+    private _file;
+    private _endpoints;
+    private isPaused;
+    private startTime;
+    private uploadedBytes;
+    private abortController;
+    private state;
+    private totalChunks;
+    private percentage;
+    private uploadedChunks;
+    private lastUploadedChunkIndex;
+    constructor(_uploadEventDispatcher: EventDispatcherInterface | undefined, //or new NodeJSEventDispatcher() if you have an environment NodeJs
+    uploadResumeData: UploadResumeCacheInterface, options: UploadOptions);
+    /**
+     * Starts the chunked file upload process.
+     *
+     * @throws {Error} If file or endpoints are not set
+     * @throws {InitializeUploadFailureException} If server initialization fails
+     * @throws {FileUploadChunkError} If a chunk fails after all retries
+     *
+     * @example
+     * ```typescript
+     * const uploader = new ChunkedFileUploader(dispatcher, cache, options);
+     *
+     * uploader
+     *   .withFile(file)
+     *   .withEndpoints({ init, upload, finalize });
+     *
+     * await uploader.upload();
+     * ```
+     */
+    upload(): Promise<void>;
+    withFile(file: File): this;
+    withEndpoints(endpoints: UploadEndpoints): this;
+    private get endPointOptions();
+    private get file();
+    /**
+     * Upload all chunks with concurrency control using p-limit
+     *
+     * @param file - File to upload
+     * @param chunkSize - Size of each chunk
+     * @param fileId - Server file ID
+     * @param fileHash - File hash
+     * @param maxRetries - Max retry attempts per chunk
+     * @param concurrency - Number of concurrent uploads (default: 3)
+     */
+    private uploadChunksWithConcurrency;
+    /**
+     * Process a single chunk: slice, upload with retry, and save progress.
+     *
+     * @param file - The file being uploaded
+     * @param currentChunkIndex - Index of the current chunk (0-based)
+     * @param chunkSize - Size of each chunk in bytes
+     * @param fileId - Server-provided file/session ID
+     * @param fileHash - SHA-256 hash of the file
+     * @param maxRetries - Maximum number of retry attempts
+     *
+     * @throws {UploadCancelledException} If upload is cancelled
+     * @throws {FileUploadChunkError} If chunk upload fails after all retries
+     */
+    private processChunk;
+    private uploadChunkWithRetry;
+    private uploadChunk;
+    private createChunkAbortSignal;
+    private notifyProgress;
+    private sleep;
+    /**
+     * Save current upload progress to cache for resume capability
+     *
+     * @param fileId - Server-provided file/session ID
+     * @param chunkSize - Size of each chunk in bytes
+     * @returns Saved resume data
+     */
+    private saveResumeData;
+    private setState;
+    getState(): UploadState;
+    private handleUploadFailure;
+    cancel(): void;
+    pause(): void;
+    resume(): void;
+    /**
+    * Load previously saved resume data
+    *
+    * @param fileName - Name of the file to resume
+    * @returns Resume data or null if not found
+    */
+    loadResumeData(fileName: string): Promise<ResumeData | null>;
+    /**
+    * Resume upload from saved state
+    *
+    * @param resumeData - Previously saved resume data
+    * @returns Upload result
+    */
+    resumeUpload(resumeData: ResumeData): Promise<void>;
+    private updateProgress;
+    private finalizeUpload;
+}
+
+export { ChunkedFileUploader };

package/dist/esm/core/index.js

@@ -0,0 +1,12 @@
+export { ChunkedFileUploader } from '../chunk-6DIKDA6J.js';
+import '../chunk-NXYS73I4.js';
+import '../chunk-MFYC4PBP.js';
+import '../chunk-X757PBC5.js';
+import '../chunk-JDL3U4OX.js';
+import '../chunk-LD2DWZRJ.js';
+import '../chunk-LTYMA4U4.js';
+import '../chunk-DN5B6PRW.js';
+import '../chunk-6225YMFE.js';
+import '../chunk-7QVYU63E.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/esm/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/esm/events/chunk/index.d.mts

@@ -0,0 +1,27 @@
+import { ChunkInfo, UploadStatus } from '../../types/index.mjs';
+import '@wlindabla/http_client';
+
+/**
+ * Event data for MEDIA_CHUNK_UPLOAD_HTTP_ERROR_RESPONSE
+ */
+declare class ChunkUploadHttpErrorResponseEvent {
+    readonly errorPayload: string | Record<string, string | unknown> | unknown;
+    readonly statusResponse: number;
+    readonly urlEndpoint: string | URL | Request;
+    readonly chunkInfo: ChunkInfo;
+    constructor(errorPayload: string | Record<string, string | unknown> | unknown, statusResponse: number, urlEndpoint: string | URL | Request, chunkInfo: ChunkInfo);
+    get chunkIndex(): number;
+}
+/**
+ * Event data for MEDIA_CHUNK_UPLOAD_STARTED
+ */
+declare class UploadChunkStartedEvent {
+    private readonly _chunkInfo;
+    constructor(_chunkInfo: ChunkInfo);
+    get start(): number;
+    get end(): number;
+    get uploadStatus(): UploadStatus;
+    get chunkIndex(): number;
+}
+
+export { ChunkUploadHttpErrorResponseEvent, UploadChunkStartedEvent };

package/dist/esm/events/chunk/index.js

@@ -0,0 +1,4 @@
+export { ChunkUploadHttpErrorResponseEvent, UploadChunkStartedEvent } from '../../chunk-LD2DWZRJ.js';
+import '../../chunk-7QVYU63E.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/esm/events/chunk/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/esm/events/complete/index.d.mts

@@ -0,0 +1,63 @@
+import { BaseEvent } from '@wlindabla/event_dispatcher';
+import { ResumeData, UploadResult } from '../../types/index.mjs';
+import { ResponseEventInterface, FetchResponseInterface } from '@wlindabla/http_client';
+
+/**
+ * Event data for MEDIA_CHUNK_UPLOAD_RESUME
+ */
+declare class ResumeUploadEvent {
+    private readonly __resumeData;
+    readonly message: string;
+    constructor(__resumeData: ResumeData, message: string);
+    get mediaId(): string | number;
+    get fileName(): string;
+    get uploadedChunks(): number;
+    get lastChunkIndex(): number;
+    get lastBytePosition(): number;
+    get chunkSize(): number;
+    get fileSize(): number;
+}
+/**
+ * Event data for DOWNLOAD_MEDIA_COMPLETE
+ */
+declare class UploadMediaCompleteEvent {
+    private readonly _uploadResult;
+    constructor(_uploadResult: UploadResult);
+    get success(): boolean;
+    get mediaId(): string | number;
+    get totalBytes(): number;
+    get totalChunks(): number;
+    get finalizeUploadHttpResponse(): any;
+    get operationDuration(): number;
+    get averageSpeed(): number;
+}
+declare class FinalizeUploadFailureEvent extends BaseEvent {
+    readonly error: Error;
+    readonly status?: number | undefined;
+    readonly errorData?: any | undefined;
+    readonly responseData?: any | undefined;
+    readonly isNetworkError?: boolean | undefined;
+    constructor(error: Error, status?: number | undefined, errorData?: any | undefined, responseData?: any | undefined, isNetworkError?: boolean | undefined);
+}
+declare class FinalizeUploadEvent extends BaseEvent implements ResponseEventInterface {
+    readonly endPoint: string | URL;
+    readonly mediaId: string;
+    readonly mediaHash: string;
+    readonly headers?: HeadersInit | undefined;
+    private fetchResponse;
+    constructor(endPoint: string | URL, mediaId: string, mediaHash: string, headers?: HeadersInit | undefined);
+    /**
+    * Returns the response
+    */
+    getResponse(): FetchResponseInterface | null;
+    /**
+     * Sets the response
+     */
+    setResponse(response: FetchResponseInterface): void;
+    /**
+   * Returns whether a response was set
+   */
+    hasResponse(): boolean;
+}
+
+export { FinalizeUploadEvent, FinalizeUploadFailureEvent, ResumeUploadEvent, UploadMediaCompleteEvent };

package/dist/esm/events/complete/index.js

@@ -0,0 +1,4 @@
+export { FinalizeUploadEvent, FinalizeUploadFailureEvent, ResumeUploadEvent, UploadMediaCompleteEvent } from '../../chunk-LTYMA4U4.js';
+import '../../chunk-7QVYU63E.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/esm/events/complete/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}