@wlindabla/file_uploader 1.0.0 → 2.0.1

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/index.ts"],"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 {\n    EventDispatcherInterface\n} from \"@wlindabla/event_dispatcher\";\n\nimport {\n    FetchResponseInterface\n} from \"@wlindabla/http_client/contracts\";\n\nimport {\n    safeFetch,\n    HttpFetchError\n} from \"@wlindabla/http_client/core\";\n\nimport {\n    ChunkError,\n    ChunkInfo,\n    ResumeData,\n    UploadEndpoints,\n    UploadOptions,\n    UploadProgress,\n    UploadResult,\n    UploadState\n} from \"../types\";\n\nimport { UploadResumeCacheInterface } from \"../cache\";\nimport {\n    FileUtils,\n    createChunkFormData\n} from \"../utils\";\n\nimport {\n    ChunkUploadHttpErrorResponseEvent,\n    HttpFileUploaderEvents,\n    InitializingUploadEvent,\n    UploadCancelledEvent,\n    UploadProgressEvent,\n    UploadStateChangedEvent,\n    UploadChunkStartedEvent,\n    UploadPausedEvent,\n    UploadResumedEvent,\n    ResumeUploadEvent,\n    FinalizeUploadEvent,\n    UploadMediaCompleteEvent\n} from \"../events\";\n\nimport { ChunkUploadHttpErrorException, FileUploadChunkError } from \"../exceptions\";\n\nimport pLimit from 'p-limit';\n\n\n/**\n * ChunkedFileUploader\n *\n * A production-ready, event-driven chunked file upload engine for Browser and Node.js.\n *\n * Designed and developed by **AGBOKOUDJO Franck** at\n * **INTERNATIONALES WEB APPS & SERVICES**, this class provides a robust,\n * framework-agnostic solution for uploading large files to a remote server\n * by splitting them into smaller chunks and sending them in parallel with\n * configurable concurrency control.\n *\n * ---\n *\n * ### How It Works\n *\n * The upload process follows a strict three-phase lifecycle:\n *\n * 1. **Initialization** — A session is opened with the server via the `init` endpoint.\n *    The file is identified by its name, size, type, and a SHA-256 hash of its\n *    first megabyte. The server returns a unique `mediaId` that identifies the session.\n *\n * 2. **Chunk Upload** — The file is sliced into fixed-size chunks and uploaded\n *    concurrently using `p-limit`. Each chunk carries its index, the total number\n *    of chunks, and the session `mediaId`. Failed chunks are retried automatically\n *    with exponential backoff up to `maxRetries` attempts.\n *\n * 3. **Finalization** — Once all chunks are successfully uploaded, the `finalize`\n *    endpoint is called to instruct the server to assemble the chunks into the\n *    final file.\n *\n * ---\n *\n * ### Event-Driven Architecture\n *\n * This class follows the **Symfony EventDispatcher pattern** via\n * `@wlindabla/event_dispatcher`. Every meaningful moment in the upload\n * lifecycle emits a typed event that your application can listen to:\n *\n * ```\n * IDLE → INITIALIZING → UPLOADING → FINALIZING → COMPLETED\n *                ↓            ↓\n *             FAILED        PAUSED ↔ UPLOADING\n *                              ↓\n *                          CANCELLED\n * ```\n *\n * All event name constants are centralized in {@link HttpFileUploaderEvents}.\n *\n * ---\n *\n * ### Subscriber Registration (Required)\n *\n * Before calling `.upload()`, you **must** register the two built-in subscribers\n * on your dispatcher. They handle the HTTP communication for the init and finalize phases:\n *\n * ```typescript\n * // Browser\n * const dispatcher = new BrowserEventDispatcher(document);\n * dispatcher.addSubscriber(new InitializeUploadSubscriber(dispatcher));\n * dispatcher.addSubscriber(new FinalizeUploadSubscriber(dispatcher));\n *\n * // Node.js\n * const dispatcher = new NodeEventDispatcher();\n * dispatcher.addSubscriber(new InitializeUploadSubscriber(dispatcher));\n * dispatcher.addSubscriber(new FinalizeUploadSubscriber(dispatcher));\n * ```\n *\n * ---\n *\n * ### Fluent Builder API\n *\n * The class exposes a fluent API to configure the upload before starting:\n *\n * ```typescript\n * const uploader = new ChunkedFileUploader(dispatcher, cache, options);\n *\n * await uploader\n *   .withFile(file)\n *   .withEndpoints({\n *     init:     'https://api.example.com/upload/init',\n *     upload:   'https://api.example.com/upload/chunk',\n *     finalize: 'https://api.example.com/upload/finalize'\n *   })\n *   .upload();\n * ```\n *\n * ---\n *\n * ### Resumable Uploads\n *\n * When `autoSave: true` is set in options, the upload progress is persisted\n * after each successful chunk via the {@link UploadResumeCacheInterface}.\n * A failed or interrupted upload can be resumed later:\n *\n * ```typescript\n * const resumeData = await uploader.loadResumeData(file.name);\n *\n * if (resumeData) {\n *   await uploader\n *     .withFile(file)\n *     .withEndpoints(endpoints)\n *     .resumeUpload(resumeData);\n * }\n * ```\n *\n * ---\n *\n * ### Concurrency\n *\n * Multiple chunks can be uploaded simultaneously. The `concurrency` option\n * controls how many parallel uploads are active at any given time.\n * The default value is `3`, which provides a good balance between speed\n * and server/network load:\n *\n * ```typescript\n * // Upload 5 chunks in parallel\n * new ChunkedFileUploader(dispatcher, cache, { concurrency: 5 });\n * ```\n *\n * ---\n *\n * ### Pause, Resume and Cancel\n *\n * The upload can be paused, resumed, or cancelled at any time:\n *\n * ```typescript\n * uploader.pause();   // Pauses after the current chunk finishes\n * uploader.resume();  // Resumes from where it was paused\n * uploader.cancel();  // Aborts immediately via AbortController\n * ```\n *\n * ---\n *\n * ### Cache\n *\n * The library does **not** provide a built-in cache implementation to stay\n * lightweight and environment-agnostic. You must implement\n * {@link UploadResumeCacheInterface} with your preferred storage backend\n * (localStorage, IndexedDB, Redis, filesystem, etc.).\n *\n * ---\n *\n * @author    AGBOKOUDJO Franck <internationaleswebservices@gmail.com>\n * @company   INTERNATIONALES WEB APPS & SERVICES\n * @phone     +229 0167 25 18 86\n * @linkedin  https://www.linkedin.com/in/internationales-web-apps-services-120520193/\n * @github    https://github.com/Agbokoudjo/file_uploader\n *\n * @version   2.0.1\n * @since     1.0.0\n * @license   MIT\n *\n * @see {@link HttpFileUploaderEvents}        All event name constants\n * @see {@link UploadResumeCacheInterface}    Cache interface to implement\n * @see {@link InitializeUploadSubscriber}    Handles the init HTTP phase\n * @see {@link FinalizeUploadSubscriber}      Handles the finalize HTTP phase\n * @see {@link UploadOptions}                 Full configuration reference\n * @see {@link https://github.com/Agbokoudjo/file_uploader | GitHub Repository}\n */\nexport class ChunkedFileUploader {\n    private _file: File |null;\n    private _endpoints: UploadEndpoints|null;\n  \n    private isPaused: boolean;\n    private startTime: number;\n    private uploadedBytes: number;\n    private abortController: AbortController;\n    private state: UploadState;\n    private totalChunks: number;\n    private percentage: number;\n    private uploadedChunks: number;\n    private lastUploadedChunkIndex: number;  \n\n    /**\n      * @param  _uploadEventDispatcher: new BrowserEventDispatcher(), //or new NodeJSEventDispatcher() if you have an environment NodeJs\n      * @param uploadResumeData: UploadResumeCacheInterface\n      * @param options: UploadOptions\n     */\n   public constructor(\n       private readonly _uploadEventDispatcher: EventDispatcherInterface,\n       private readonly uploadResumeData: UploadResumeCacheInterface,\n       private options: UploadOptions\n   ) {\n     \n       this._file = null;\n       this._endpoints = null;\n       this.isPaused = false;\n       this.startTime = 0;\n       this.uploadedBytes = 0;\n       this.abortController = new AbortController();\n       this.state = UploadState.IDLE;\n       this.totalChunks = 0;\n       this.percentage = 0;\n       this.uploadedChunks = 0;\n       this.lastUploadedChunkIndex = -1;  \n   }\n\n    /**\n     * Starts the chunked file upload process.\n     * \n     * @throws {Error} If file or endpoints are not set\n     * @throws {InitializeUploadFailureException} If server initialization fails\n     * @throws {FileUploadChunkError} If a chunk fails after all retries\n     * \n     * @example\n     * ```typescript\n     * const uploader = new ChunkedFileUploader(dispatcher, cache, options);\n     * \n     * uploader\n     *   .withFile(file)\n     *   .withEndpoints({ init, upload, finalize });\n     * \n     * await uploader.upload();\n     * ```\n     */\n    public async upload(): Promise<void>{\n        this.setState(UploadState.INITIALIZING);\n\n        const { maxRetries = 3, config, speedMbps, metadata,\n            headerInitialzingUpload, concurrency = 3\n        } = this.options;\n\n        let file: File;\n        try {\n            file = this.file;\n        } catch (error) {\n           throw error;\n        }\n        \n        // Generate file hash for integrity check\n        const fileHash = await FileUtils.generateFileHash(this.file); \n        let fileId: string;\n       try {\n           const initializationEvent = await this._uploadEventDispatcher.dispatchAsync(\n               new InitializingUploadEvent(\n                   {\n                       fileHash: fileHash,\n                       fileName: file.name,\n                       fileSize: file.size,\n                       fileType: file.type,\n                       metadata: metadata,\n                       endpointInit: this.endPointOptions.init,\n                       headers: headerInitialzingUpload\n                   }),\n               HttpFileUploaderEvents.INITIALIZE_UPLOAD\n           )\n\n           fileId = initializationEvent.mediaId;\n       } catch (error) {\n           this.setState(UploadState.FAILED);\n           throw error;\n       }\n\n        this.setState(UploadState.UPLOADING);\n        this.startTime = Date.now();\n        this.uploadedBytes = 0;\n        this.uploadedChunks = 0;\n        this.lastUploadedChunkIndex = -1;\n\n        const chunkSize = this.options.chunkSize || FileUtils.calculateChunkSize(file.size, speedMbps, config);\n        this.totalChunks = Math.ceil(file.size / chunkSize);\n        try {\n            await this.uploadChunksWithConcurrency(\n                file,\n                chunkSize,\n                fileId,\n                fileHash,\n                maxRetries,\n                concurrency,\n                0\n            );\n\n            await this.finalizeUpload(fileId, fileHash);\n            \n        } catch (error) {\n            this.handleUploadFailure(error as Error);\n            throw error;\n        }\n    }\n\n    public withFile(file: File): this {\n        if (!file) {\n            throw new Error('File is required');\n        }\n        if (file.size === 0) {\n            throw new Error('Cannot upload empty file');\n        }\n        if (!(file instanceof File) || !(file instanceof Blob)) {\n            throw new TypeError('Expected File or Blob instance');\n        }\n        this._file = file;\n        return this;\n    }\n\n    public withEndpoints(endpoints: UploadEndpoints): this {\n        if (!endpoints.init || !endpoints.upload || !endpoints.finalize) {\n            throw new Error('All endpoints (init, upload, finalize) are required');\n        }\n        this._endpoints = endpoints;\n        return this;\n    }\n\n    private get endPointOptions():UploadEndpoints {\n        if (!this._endpoints) {\n            throw new Error('Endpoint URL is required');\n        }\n\n        return this._endpoints;\n    }\n\n    private get file(): File{ \n        if (!this._file) {\n            throw new Error(`\n                This operation requires a mandatory file.Did you forget to upload the file?  \n                Use the withFile(file: File|Blob) function of the ChunkedFileUploader ${this} class that you instantiated.\n                `)\n        }\n\n        return this._file;\n    }\n\n    /**\n     * Upload all chunks with concurrency control using p-limit\n     * \n     * @param file - File to upload\n     * @param chunkSize - Size of each chunk\n     * @param fileId - Server file ID\n     * @param fileHash - File hash\n     * @param maxRetries - Max retry attempts per chunk\n     * @param concurrency - Number of concurrent uploads (default: 3)\n     */\n    private async uploadChunksWithConcurrency(\n        file: File,\n        chunkSize: number,\n        fileId: string,\n        fileHash: string,\n        maxRetries: number,\n        concurrency: number,\n        startIndex:number=0\n    ): Promise<void> {\n       try {\n         const limit = pLimit(concurrency);\n\n        // Créer toutes les promesses avec limite\n        const uploadPromises: Promise<void>[] = [];\n\n        for (let chunkIndex = startIndex; chunkIndex < this.totalChunks; chunkIndex++) {\n            // Wrapper chaque upload dans le limiteur\n            const limitedUpload = limit(() =>\n                this.processChunk(\n                    file,\n                    chunkIndex,\n                    chunkSize,\n                    fileId,\n                    fileHash,\n                    maxRetries\n                )\n            );\n\n            uploadPromises.push(limitedUpload);\n        }\n\n        // Attendre que tous les chunks soient uploadés\n        await Promise.all(uploadPromises);\n       } catch (error) {\n           throw error;\n       }\n    }\n\n    /**\n     * Process a single chunk: slice, upload with retry, and save progress.\n     * \n     * @param file - The file being uploaded\n     * @param currentChunkIndex - Index of the current chunk (0-based)\n     * @param chunkSize - Size of each chunk in bytes\n     * @param fileId - Server-provided file/session ID\n     * @param fileHash - SHA-256 hash of the file\n     * @param maxRetries - Maximum number of retry attempts\n     * \n     * @throws {UploadCancelledException} If upload is cancelled\n     * @throws {FileUploadChunkError} If chunk upload fails after all retries\n     */\n    private async processChunk(\n        file:File,\n        currentChunkIndex: number,\n        chunkSize:number,\n        fileId: string,\n        fileHash:string,\n        maxRetries:number\n        ): Promise<void>{\n        try {\n            if (this.abortController.signal.aborted) {\n                this._uploadEventDispatcher.dispatch(\n                    new UploadCancelledEvent(\n                        file.name,\n                        this.totalChunks,\n                        this.uploadedBytes,\n                        this.percentage,\n                        currentChunkIndex,\n                        'Upload cancelled by user',\n                        Date.now()\n                    ),\n                    HttpFileUploaderEvents.UPLOAD_CANCELLED\n                    )\n                    \n                return;\n                }\n\n            while (this.isPaused) {\n                await this.sleep(100);\n            }\n                // Calcule où commencer dans le fichier\n            const start = currentChunkIndex * chunkSize;\n                // chunkIndex=0 → start=0\n                // chunkIndex=1 → start=300\n                // chunkIndex=2 → start=600\n                // chunkIndex=3 → start=900\n\n                // Calcule où finir (sans depasser la fin du fichier)\n                const end = Math.min(file.size, start + chunkSize);\n                // chunkIndex=0 → end=min(1000, 300)=300\n                // chunkIndex=1 → end=min(1000, 600)=600\n                // chunkIndex=2 → end=min(1000, 900)=900\n                // chunkIndex=3 → end=min(1000, 1200)=1000 ← Limité !\n\n                // Découpe le morceau\n                const chunk = file.slice(start, end);\n                // chunkIndex=0 → slice(0, 300)   → 300 bytes\n                // chunkIndex=1 → slice(300, 600) → 300 bytes\n                // chunkIndex=2 → slice(600, 900) → 300 bytes\n                // chunkIndex=3 → slice(900, 1000)→ 100 bytes ← Plus petit !\n                const chunkInfo: ChunkInfo = {\n                    index: currentChunkIndex,\n                    start,\n                    end,\n                    size: chunk.size,\n                    attempt: 0,\n                    status: 'pending'\n                };\n\n            this._uploadEventDispatcher.dispatch(\n                new UploadChunkStartedEvent(chunkInfo),\n                HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_STARTED\n            );\n                // Upload with retry\n                await this.uploadChunkWithRetry(\n                    chunk,\n                    chunkInfo,\n                    fileId,\n                    fileHash,\n                    this.totalChunks,\n                    maxRetries\n                );\n\n            // Auto-save progress\n            if (this.options.autoSave) {\n                await this.saveResumeData(fileId,chunkSize);\n            }\n        } catch (error) {\n            throw error;\n            \n        }\n    }\n\n    private async uploadChunkWithRetry(\n        chunk: Blob,\n        chunkInfo: ChunkInfo,\n        fileId: string,\n        fileHash: string,\n        totalChunks: number,\n        maxRetries: number\n    ): Promise<void> {\n        let success = false;\n        let lastError: Error | null = null;\n\n        for (let attempt = 0; attempt < maxRetries && !success; attempt++) {\n            chunkInfo.attempt = attempt + 1;\n            chunkInfo.status = 'uploading';\n\n            try {\n                const response = await this.uploadChunk(chunk, chunkInfo, fileId, fileHash, totalChunks);\n                success = true;\n                chunkInfo.status = 'success';\n\n                this.updateProgress(chunk.size, chunkInfo.index)\n\n                this.notifyProgress(\n                    this.uploadedChunks,\n                    totalChunks,\n                    this.file.size,\n                    response\n                );\n                return;\n            } catch (error) {\n                if (error instanceof ChunkUploadHttpErrorException) {\n                    this._uploadEventDispatcher.dispatch(\n                        new ChunkUploadHttpErrorResponseEvent(\n                            error.errorPayload,\n                            error.statusResponse,\n                            this.endPointOptions.upload,\n                            chunkInfo),\n                        HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_HTTP_ERROR_RESPONSE\n                        )\n                }\n\n                lastError = error as Error;\n                chunkInfo.status = 'error';\n\n                const chunkError: ChunkError= {\n                    chunk: chunkInfo,\n                    error: lastError,\n                    attempt: attempt + 1,\n                    willRetry: attempt < maxRetries - 1\n                };\n\n               if(error instanceof HttpFetchError){\n                   this._uploadEventDispatcher.dispatch(chunkError,HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_FAILED)\n               }\n\n                if (attempt < maxRetries - 1) {\n                    const delay = Math.pow(2, attempt) * 1000;\n                    await this.sleep(delay);\n\n                    console.info(`Retry #${attempt + 2} in ${delay / 1000}s...`);\n                }\n            }\n        }\n\n        if (!success) {\n            const fileUploadChunkError = new FileUploadChunkError(\n                `Failed to upload chunk ${chunkInfo.index} after ${maxRetries} attempts`,\n                {\n                    chunk: chunkInfo,\n                    error: lastError!,\n                    attempt: maxRetries,\n                    willRetry: false\n                }\n            );\n\n            this._uploadEventDispatcher.dispatch(\n                fileUploadChunkError,\n                HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_MAXRETRY_EXPIRE\n            )\n            \n            throw fileUploadChunkError;\n        }\n\n    }\n\n    private async uploadChunk(\n        chunk: Blob,\n        chunkInfo: ChunkInfo,\n        mediaIdFromServer: string,\n        fileHash: string,\n        totalChunks: number\n    ): Promise<FetchResponseInterface> {\n        const media = this.file;\n        const chunkFormData = createChunkFormData(\n            chunk,\n            {\n                chunkIndex: chunkInfo.index,\n                mediaId: mediaIdFromServer,\n                fileSize: media.size,\n                fileName: media.name,\n                fileHash: fileHash,\n                totalChunks: totalChunks\n            }\n        );\n\n        try {\n            const response_of_server = await safeFetch({\n                url: this.endPointOptions.upload,\n                headers: this.options.headers,\n                data: chunkFormData,\n                methodSend: \"POST\",\n                responseType: \"json\",\n                timeout: this.options.timeout ?? 60000,\n                retryCount: 2,\n                retryOnStatusCode: false,\n                signal: this.createChunkAbortSignal()\n            })\n            const statusResponse = response_of_server.status;\n            //if the server send a response which not success with status code(>=4XX ou >=5XX)\n            if (response_of_server.failed) {\n                throw new ChunkUploadHttpErrorException(response_of_server.data, statusResponse)\n            }\n\n            return response_of_server;\n        } catch (error) {\n            throw error;\n        }\n\n    }\n\n    private createChunkAbortSignal(): AbortSignal {\n        const chunkController = new AbortController();\n\n        this.abortController.signal.addEventListener('abort', () => {\n            chunkController.abort();\n        });\n\n        return chunkController.signal;\n    }\n\n    private notifyProgress(\n        uploadedChunks: number,\n        totalChunks: number,\n        totalBytes: number,\n        httpResponse: FetchResponseInterface): void {\n        // Temps écoulé (minimum 0.1s pour éviter division par zéro)\n        const elapsed = Math.max((Date.now() - this.startTime) / 1000, 0.1);\n        const speed = this.uploadedBytes / elapsed;  // Vitesse instantanée\n        const remainingBytes = totalBytes - this.uploadedBytes; // Bytes restants\n        // Temps restant (null si pas assez de données)\n        const estimatedTimeRemaining = uploadedChunks < 2 ? null : remainingBytes / speed;\n\n        this.percentage = Math.round((this.uploadedBytes / totalBytes) * 100);\n\n        const progress: UploadProgress = {\n            uploadedChunks,\n            totalChunks,\n            uploadedBytes: this.uploadedBytes,\n            totalBytes,\n            percentage: this.percentage,\n            currentChunk: uploadedChunks,\n            speed, // bytes/seconde\n            estimatedTimeRemaining, // secondes (ou null)\n            elapsed // secondes écoulées\n        };\n\n        this._uploadEventDispatcher.dispatch(\n            new UploadProgressEvent(\n                progress,\n                httpResponse.data,\n                httpResponse.status\n            )\n        )\n       \n        console.info(\n            `Progress: ${this.percentage}% | ` +\n            `Speed: ${FileUtils.formatBytes(speed)}/s | ` +\n            `ETA: ${estimatedTimeRemaining ? FileUtils.formatDuration(estimatedTimeRemaining) : 'Calculating...'}`\n        );\n    }\n\n    private sleep(ms: number): Promise<void> {\n        return new Promise(resolve => setTimeout(resolve, ms));\n    }\n\n    /**\n     * Save current upload progress to cache for resume capability\n     * \n     * @param fileId - Server-provided file/session ID\n     * @param chunkSize - Size of each chunk in bytes\n     * @returns Saved resume data\n     */\n    private async saveResumeData(fileId: string, chunkSize: number): Promise<ResumeData> {\n        const data: ResumeData = {\n            fileId: fileId,\n            fileName: this.file.name,\n            fileSize: this.file.size,\n            uploadedChunks: this.uploadedChunks,\n            lastChunkIndex: this.lastUploadedChunkIndex,\n            lastBytePosition: this.uploadedBytes,\n            chunkSize: chunkSize,\n            concurrency:this.options.concurrency || 3\n        };\n\n        await this.uploadResumeData.setItem(`upload_${this.file.name}`, data);\n\n        console.info(\n            `Resume data saved: ${this.uploadedChunks}/${Math.ceil(this.file.size / chunkSize)} chunks, ` +\n            `last chunk index: ${this.lastUploadedChunkIndex}`\n        );\n\n        return data;\n    }\n\n    private setState(newState: UploadState): void {\n        const oldState = this.state;\n        this.state = newState;\n\n        this._uploadEventDispatcher.dispatch(\n            new UploadStateChangedEvent(\n                oldState,\n                newState,\n                Date.now()\n            ),\n            HttpFileUploaderEvents.UPLOAD_STATE_CHANGED\n        )\n            \n    }\n\n    public getState(): UploadState {\n        return this.state;\n    }\n\n    private handleUploadFailure(error: Error): void {\n        this.setState(UploadState.FAILED);\n\n        this._uploadEventDispatcher.dispatch(error, HttpFileUploaderEvents.DOWNLOAD_MEDIA_FAILURE);\n        console.error('Upload failed:', error);\n    }\n\n    public cancel(): void {\n        this.abortController.abort();\n        this.setState(UploadState.CANCELLED);\n    }\n\n    public pause(): void {\n        this.isPaused = true;\n        this.setState(UploadState.PAUSED);\n         this._uploadEventDispatcher.dispatch(\n             new UploadPausedEvent(\n                this.file.name,\n                this.totalChunks,\n                this.uploadedBytes,\n                this.percentage,\n                Date.now()\n            ),\n            HttpFileUploaderEvents.UPLOAD_PAUSED\n        );\n    }\n\n\n    public resume(): void {\n        this.isPaused = false;\n        this.setState(UploadState.UPLOADING);\n        this._uploadEventDispatcher.dispatch(\n            new UploadResumedEvent(\n                this.file.name,\n                this.totalChunks,\n                this.uploadedBytes, \n                this.percentage),\n             HttpFileUploaderEvents.UPLOAD_RESUMED,\n        );\n    }\n\n    /**\n    * Load previously saved resume data\n    * \n    * @param fileName - Name of the file to resume\n    * @returns Resume data or null if not found\n    */\n    async loadResumeData(fileName: string): Promise<ResumeData | null> {\n        try {\n            const data = await this.uploadResumeData.getItem(`upload_${fileName}`);\n\n            if (data) {\n                console.info(\n                    `Resume data loaded: ${data.uploadedChunks} chunks uploaded, ` +\n                    `last index: ${data.lastChunkIndex}`\n                );\n            }\n            return data;\n        } catch (error) {\n            console.warn(`No resume data found for ${fileName}`);\n            return null;\n        }\n    }\n\n    /**\n    * Resume upload from saved state\n    * \n    * @param resumeData - Previously saved resume data\n    * @returns Upload result\n    */\n    public async resumeUpload(resumeData: ResumeData): Promise<void> {\n        const __message = `Resuming upload from chunk ${resumeData.lastChunkIndex + 1} ` +\n            `(${resumeData.uploadedChunks} chunks already uploaded)`;\n\n        // Restore state\n        this.uploadedBytes = resumeData.lastBytePosition;\n        this.uploadedChunks = resumeData.uploadedChunks;\n        this.lastUploadedChunkIndex = resumeData.lastChunkIndex;\n\n        // Calculate adjusted start time for accurate speed calculation\n        const assumedSpeed = 500000; // 500 KB/s assumed\n        const timeAlreadySpent = resumeData.lastBytePosition / assumedSpeed;\n        this.startTime = Date.now() - (timeAlreadySpent * 1000);\n\n        const { maxRetries = 3 } = this.options;\n        const fileHash = await FileUtils.generateFileHash(this.file);\n        const chunkSize = resumeData.chunkSize;\n        this.totalChunks = Math.ceil(this.file.size / chunkSize);\n\n        try {\n            this._uploadEventDispatcher.dispatch(\n                new ResumeUploadEvent(resumeData,__message),\n                   HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_RESUME\n            )\n            await this.uploadChunksWithConcurrency(\n                this.file,\n                chunkSize,\n                resumeData.fileId,\n                fileHash,\n                 maxRetries,\n                resumeData.concurrency,\n                resumeData.lastChunkIndex + 1\n            )\n                ;\n            await this.finalizeUpload(resumeData.fileId, fileHash);\n\n        } catch (error) {\n            this.handleUploadFailure(error as Error);\n            throw error;\n        }\n    }\n\n    private updateProgress(chunkSize: number, chunkIndex: number): void {\n        this.uploadedBytes += chunkSize;\n        this.uploadedChunks++;\n        this.lastUploadedChunkIndex = Math.max(this.lastUploadedChunkIndex,chunkIndex);\n    }\n    \n    private async finalizeUpload(mediaId: string, fileHash: string): Promise<void>  {\n        try {\n            \n            const finalizeUploadEvent = await this._uploadEventDispatcher.dispatchAsync(\n                new FinalizeUploadEvent(\n                    this.endPointOptions.finalize,\n                    mediaId,\n                    fileHash,\n                 this.options.headerFinalezingUpload)\n               ,\n                HttpFileUploaderEvents.FINALIZE_UPLOAD\n            )\n\n            this.setState(UploadState.FINALIZING);\n\n\n            const duration = (Date.now() - this.startTime) / 1000;\n\n            const uploadResult: UploadResult = {\n                success: true,\n                finalizeUploadResponse: finalizeUploadEvent.hasResponse() ? finalizeUploadEvent.getResponse() : null ,\n                totalChunks: this.totalChunks,\n                totalBytes: this.file.size,\n                duration,\n                averageSpeed: this.file.size / duration,\n                fileId: mediaId\n            };\n\n            this.setState(UploadState.COMPLETED);\n\n            this._uploadEventDispatcher.dispatch(\n                new UploadMediaCompleteEvent(uploadResult),HttpFileUploaderEvents.DOWNLOAD_MEDIA_COMPLETE\n            )\n\n        } catch (error) {\n            throw error;\n        }\n    }\n}"],"mappings":"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","names":["pLimit"]}

package/dist/cjs/events/chunk/index.d.ts

@@ -0,0 +1,27 @@
+import { ChunkInfo, UploadStatus } from '../../types/index.js';
+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/cjs/events/chunk/index.js

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_exports = {};
+__export(chunk_exports, {
+  ChunkUploadHttpErrorResponseEvent: () => ChunkUploadHttpErrorResponseEvent,
+  UploadChunkStartedEvent: () => UploadChunkStartedEvent
+});
+module.exports = __toCommonJS(chunk_exports);
+class ChunkUploadHttpErrorResponseEvent {
+  constructor(errorPayload, statusResponse, urlEndpoint, chunkInfo) {
+    this.errorPayload = errorPayload;
+    this.statusResponse = statusResponse;
+    this.urlEndpoint = urlEndpoint;
+    this.chunkInfo = chunkInfo;
+  }
+  errorPayload;
+  statusResponse;
+  urlEndpoint;
+  chunkInfo;
+  static {
+    __name(this, "ChunkUploadHttpErrorResponseEvent");
+  }
+  get chunkIndex() {
+    return this.chunkInfo.index;
+  }
+}
+class UploadChunkStartedEvent {
+  constructor(_chunkInfo) {
+    this._chunkInfo = _chunkInfo;
+  }
+  _chunkInfo;
+  static {
+    __name(this, "UploadChunkStartedEvent");
+  }
+  get start() {
+    return this._chunkInfo.start;
+  }
+  get end() {
+    return this._chunkInfo.end;
+  }
+  get uploadStatus() {
+    return this._chunkInfo.status;
+  }
+  get chunkIndex() {
+    return this._chunkInfo.index;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChunkUploadHttpErrorResponseEvent,
+  UploadChunkStartedEvent
+});
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/events/chunk/index.ts"],"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 */\nimport { ChunkInfo, UploadStatus } from \"../../types\";\n\n/**\n * Event data for MEDIA_CHUNK_UPLOAD_HTTP_ERROR_RESPONSE\n */\nexport class ChunkUploadHttpErrorResponseEvent {\n    constructor(\n        public readonly errorPayload: string | Record<string, string | unknown> | unknown,\n        public readonly statusResponse: number,\n        public readonly urlEndpoint: string | URL | Request,\n        public readonly chunkInfo: ChunkInfo\n    ) { }\n\n    public get chunkIndex(): number { return this.chunkInfo.index; }\n}\n\n/**\n * Event data for MEDIA_CHUNK_UPLOAD_STARTED\n */\nexport class UploadChunkStartedEvent {\n    constructor(private readonly _chunkInfo: ChunkInfo) { }\n\n    public get start(): number { return this._chunkInfo.start; }\n\n    public get end(): number { return this._chunkInfo.end; }\n\n    public get uploadStatus(): UploadStatus { return this._chunkInfo.status; }\n\n    public get chunkIndex(): number { return this._chunkInfo.index; }\n}"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAeO,MAAM,kCAAkC;AAAA,EAC3C,YACoB,cACA,gBACA,aACA,WAClB;AAJkB;AACA;AACA;AACA;AAAA,EAChB;AAAA,EAJgB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EApBxB,OAe+C;AAAA;AAAA;AAAA,EAQ3C,IAAW,aAAqB;AAAE,WAAO,KAAK,UAAU;AAAA,EAAO;AACnE;AAKO,MAAM,wBAAwB;AAAA,EACjC,YAA6B,YAAuB;AAAvB;AAAA,EAAyB;AAAA,EAAzB;AAAA,EA9BjC,OA6BqC;AAAA;AAAA;AAAA,EAGjC,IAAW,QAAgB;AAAE,WAAO,KAAK,WAAW;AAAA,EAAO;AAAA,EAE3D,IAAW,MAAc;AAAE,WAAO,KAAK,WAAW;AAAA,EAAK;AAAA,EAEvD,IAAW,eAA6B;AAAE,WAAO,KAAK,WAAW;AAAA,EAAQ;AAAA,EAEzE,IAAW,aAAqB;AAAE,WAAO,KAAK,WAAW;AAAA,EAAO;AACpE;","names":[]}

package/dist/cjs/events/complete/index.d.ts

@@ -0,0 +1,64 @@
+import { BaseEvent } from '@wlindabla/event_dispatcher';
+import { ResumeData, UploadResult } from '../../types/index.js';
+import { ResponseEventInterface } from '@wlindabla/http_client/events';
+import { 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/cjs/events/complete/index.js

@@ -0,0 +1,152 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var complete_exports = {};
+__export(complete_exports, {
+  FinalizeUploadEvent: () => FinalizeUploadEvent,
+  FinalizeUploadFailureEvent: () => FinalizeUploadFailureEvent,
+  ResumeUploadEvent: () => ResumeUploadEvent,
+  UploadMediaCompleteEvent: () => UploadMediaCompleteEvent
+});
+module.exports = __toCommonJS(complete_exports);
+var import_event_dispatcher = require("@wlindabla/event_dispatcher");
+class ResumeUploadEvent {
+  constructor(__resumeData, message) {
+    this.__resumeData = __resumeData;
+    this.message = message;
+  }
+  __resumeData;
+  message;
+  static {
+    __name(this, "ResumeUploadEvent");
+  }
+  get mediaId() {
+    return this.__resumeData.fileId;
+  }
+  get fileName() {
+    return this.__resumeData.fileName;
+  }
+  get uploadedChunks() {
+    return this.__resumeData.uploadedChunks;
+  }
+  get lastChunkIndex() {
+    return this.__resumeData.lastChunkIndex;
+  }
+  get lastBytePosition() {
+    return this.__resumeData.lastBytePosition;
+  }
+  get chunkSize() {
+    return this.__resumeData.chunkSize;
+  }
+  get fileSize() {
+    return this.__resumeData.fileSize;
+  }
+}
+class UploadMediaCompleteEvent {
+  constructor(_uploadResult) {
+    this._uploadResult = _uploadResult;
+  }
+  _uploadResult;
+  static {
+    __name(this, "UploadMediaCompleteEvent");
+  }
+  get success() {
+    return this._uploadResult.success;
+  }
+  get mediaId() {
+    return this._uploadResult.fileId;
+  }
+  get totalBytes() {
+    return this._uploadResult.totalBytes;
+  }
+  get totalChunks() {
+    return this._uploadResult.totalChunks;
+  }
+  get finalizeUploadHttpResponse() {
+    return this._uploadResult.finalizeUploadResponse;
+  }
+  get operationDuration() {
+    return this._uploadResult.duration;
+  }
+  get averageSpeed() {
+    return this._uploadResult.averageSpeed;
+  }
+}
+class FinalizeUploadFailureEvent extends import_event_dispatcher.BaseEvent {
+  constructor(error, status, errorData, responseData, isNetworkError) {
+    super();
+    this.error = error;
+    this.status = status;
+    this.errorData = errorData;
+    this.responseData = responseData;
+    this.isNetworkError = isNetworkError;
+  }
+  error;
+  status;
+  errorData;
+  responseData;
+  isNetworkError;
+  static {
+    __name(this, "FinalizeUploadFailureEvent");
+  }
+}
+class FinalizeUploadEvent extends import_event_dispatcher.BaseEvent {
+  constructor(endPoint, mediaId, mediaHash, headers) {
+    super();
+    this.endPoint = endPoint;
+    this.mediaId = mediaId;
+    this.mediaHash = mediaHash;
+    this.headers = headers;
+    this.fetchResponse = null;
+  }
+  endPoint;
+  mediaId;
+  mediaHash;
+  headers;
+  static {
+    __name(this, "FinalizeUploadEvent");
+  }
+  fetchResponse;
+  /**
+  * Returns the response
+  */
+  getResponse() {
+    return this.fetchResponse;
+  }
+  /**
+   * Sets the response
+   */
+  setResponse(response) {
+    this.fetchResponse = response;
+  }
+  /**
+  * Returns whether a response was set
+  */
+  hasResponse() {
+    return this.fetchResponse !== null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FinalizeUploadEvent,
+  FinalizeUploadFailureEvent,
+  ResumeUploadEvent,
+  UploadMediaCompleteEvent
+});
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/events/complete/index.ts"],"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 */\nimport { BaseEvent } from \"@wlindabla/event_dispatcher\";\nimport { ResumeData, UploadResult } from \"../../types\";\n\nimport type {\n    ResponseEventInterface\n} from \"@wlindabla/http_client/events\";\n\nimport type {\n    FetchResponseInterface\n} from \"@wlindabla/http_client\";\n\n/**\n * Event data for MEDIA_CHUNK_UPLOAD_RESUME\n */\nexport class ResumeUploadEvent {\n    constructor(\n        private readonly __resumeData: ResumeData,\n        public readonly message: string) { }\n\n    public get mediaId(): string | number { return this.__resumeData.fileId; }\n\n    public get fileName(): string { return this.__resumeData.fileName; }\n\n    public get uploadedChunks(): number { return this.__resumeData.uploadedChunks; }\n\n    public get lastChunkIndex(): number { return this.__resumeData.lastChunkIndex; }\n\n    public get lastBytePosition(): number { return this.__resumeData.lastBytePosition; }\n\n    public get chunkSize(): number { return this.__resumeData.chunkSize; }\n\n    public get fileSize(): number { return this.__resumeData.fileSize; }\n}\n\n/**\n * Event data for DOWNLOAD_MEDIA_COMPLETE\n */\nexport class UploadMediaCompleteEvent {\n    constructor(private readonly _uploadResult: UploadResult) { }\n\n    public get success(): boolean { return this._uploadResult.success; }\n\n    public get mediaId(): string | number { return this._uploadResult.fileId! }\n\n    public get totalBytes(): number { return this._uploadResult.totalBytes; }\n\n    public get totalChunks(): number { return this._uploadResult.totalChunks; }\n\n    public get finalizeUploadHttpResponse(): any { return this._uploadResult.finalizeUploadResponse; }\n\n    public get operationDuration(): number { return this._uploadResult.duration; }\n\n    public get averageSpeed(): number { return this._uploadResult.averageSpeed; }\n}\n\nexport class FinalizeUploadFailureEvent extends BaseEvent{\n    constructor(\n        public readonly error: Error,\n        public readonly status?: number,\n        public readonly errorData?: any,\n        public readonly responseData?: any,\n        public readonly isNetworkError?: boolean\n    ) { super(); }\n}\n\nexport class FinalizeUploadEvent extends BaseEvent implements ResponseEventInterface{\n    private fetchResponse: FetchResponseInterface|null;\n\n    constructor(\n        public readonly endPoint:string|URL,\n        public readonly mediaId: string,\n        public readonly mediaHash: string,\n        public readonly headers?: HeadersInit\n    ) {\n        super();\n        this.fetchResponse = null;\n    }\n\n    /**\n    * Returns the response\n    */\n    public getResponse(): FetchResponseInterface | null {\n        return this.fetchResponse;\n    }\n\n    /**\n     * Sets the response\n     */\n    public setResponse(response: FetchResponseInterface): void {\n        this.fetchResponse = response;\n    }\n\n    /**\n   * Returns whether a response was set\n   */\n    public hasResponse(): boolean {\n        return this.fetchResponse !== null;\n    }\n}"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,8BAA0B;AAcnB,MAAM,kBAAkB;AAAA,EAC3B,YACqB,cACD,SAAiB;AADhB;AACD;AAAA,EAAmB;AAAA,EADlB;AAAA,EACD;AAAA,EA3BxB,OAwB+B;AAAA;AAAA;AAAA,EAK3B,IAAW,UAA2B;AAAE,WAAO,KAAK,aAAa;AAAA,EAAQ;AAAA,EAEzE,IAAW,WAAmB;AAAE,WAAO,KAAK,aAAa;AAAA,EAAU;AAAA,EAEnE,IAAW,iBAAyB;AAAE,WAAO,KAAK,aAAa;AAAA,EAAgB;AAAA,EAE/E,IAAW,iBAAyB;AAAE,WAAO,KAAK,aAAa;AAAA,EAAgB;AAAA,EAE/E,IAAW,mBAA2B;AAAE,WAAO,KAAK,aAAa;AAAA,EAAkB;AAAA,EAEnF,IAAW,YAAoB;AAAE,WAAO,KAAK,aAAa;AAAA,EAAW;AAAA,EAErE,IAAW,WAAmB;AAAE,WAAO,KAAK,aAAa;AAAA,EAAU;AACvE;AAKO,MAAM,yBAAyB;AAAA,EAClC,YAA6B,eAA6B;AAA7B;AAAA,EAA+B;AAAA,EAA/B;AAAA,EAhDjC,OA+CsC;AAAA;AAAA;AAAA,EAGlC,IAAW,UAAmB;AAAE,WAAO,KAAK,cAAc;AAAA,EAAS;AAAA,EAEnE,IAAW,UAA2B;AAAE,WAAO,KAAK,cAAc;AAAA,EAAQ;AAAA,EAE1E,IAAW,aAAqB;AAAE,WAAO,KAAK,cAAc;AAAA,EAAY;AAAA,EAExE,IAAW,cAAsB;AAAE,WAAO,KAAK,cAAc;AAAA,EAAa;AAAA,EAE1E,IAAW,6BAAkC;AAAE,WAAO,KAAK,cAAc;AAAA,EAAwB;AAAA,EAEjG,IAAW,oBAA4B;AAAE,WAAO,KAAK,cAAc;AAAA,EAAU;AAAA,EAE7E,IAAW,eAAuB;AAAE,WAAO,KAAK,cAAc;AAAA,EAAc;AAChF;AAEO,MAAM,mCAAmC,kCAAS;AAAA,EACrD,YACoB,OACA,QACA,WACA,cACA,gBAClB;AAAE,UAAM;AALU;AACA;AACA;AACA;AACA;AAAA,EACP;AAAA,EALO;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAvExB,OAiEyD;AAAA;AAAA;AAQzD;AAEO,MAAM,4BAA4B,kCAA2C;AAAA,EAGhF,YACoB,UACA,SACA,WACA,SAClB;AACE,UAAM;AALU;AACA;AACA;AACA;AAGhB,SAAK,gBAAgB;AAAA,EACzB;AAAA,EAPoB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAlFxB,OA2EoF;AAAA;AAAA;AAAA,EACxE;AAAA;AAAA;AAAA;AAAA,EAeD,cAA6C;AAChD,WAAO,KAAK;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA,EAKO,YAAY,UAAwC;AACvD,SAAK,gBAAgB;AAAA,EACzB;AAAA;AAAA;AAAA;AAAA,EAKO,cAAuB;AAC1B,WAAO,KAAK,kBAAkB;AAAA,EAClC;AACJ;","names":[]}

package/dist/cjs/events/index.d.ts

@@ -0,0 +1,95 @@
+export { InitializeUploadFailureEvent, InitializeUploadStartedEvent, InitializeUploadSuccessEvent, InitializingUploadEvent } from './initialize/index.js';
+export { UploadCancelledEvent, UploadPausedEvent, UploadProgressEvent, UploadResumedEvent, UploadStateChangedEvent } from './state/index.js';
+export { ChunkUploadHttpErrorResponseEvent, UploadChunkStartedEvent } from './chunk/index.js';
+export { FinalizeUploadEvent, FinalizeUploadFailureEvent, ResumeUploadEvent, UploadMediaCompleteEvent } from './complete/index.js';
+import '../types/index.js';
+import '@wlindabla/http_client';
+import '@wlindabla/event_dispatcher';
+import '@wlindabla/http_client/events';
+
+/**
+ * HttpFileUploaderEvents - Event Constants for File Upload Operations
+ *
+ * This abstract class provides a centralized collection of event name constants
+ * used throughout the file upload lifecycle. It follows the Symfony event
+ * dispatcher pattern, providing a type-safe way to reference events.
+ *
+ * The events are organized into five categories:
+ * - **Initialize Events**: Events related to upload session initialization
+ * - **Chunk Upload Events**: Events fired during individual chunk uploads
+ * - **Upload State Events**: Events tracking upload state changes (pause, resume, cancel)
+ * - **Completion Events**: Events fired when upload completes or fails
+ * - **Metadata Events**: Events related to media metadata operations
+ *
+ * @example
+ * ```typescript
+ * import { HttpFileUploaderEvents } from '@wlindabla/file_uploader';
+ *
+ * // Listen to chunk upload success
+ * dispatcher.addListener(
+ *   HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_SUCCESS,
+ *   (event: ChunkUploadSuccessEvent) => {
+ *     console.log('Chunk uploaded:', event.progress);
+ *   }
+ * );
+ *
+ * // Listen to upload state changes
+ * dispatcher.addListener(
+ *   HttpFileUploaderEvents.UPLOAD_STATE_CHANGED,
+ *   (event: UploadStateChangedEvent) => {
+ *     console.log(`State changed: ${event.oldState} → ${event.newState}`);
+ *   }
+ * );
+ * ```
+ *
+ * @author AGBOKOUDJO Franck <internationaleswebservices@gmail.com>
+ * @version 1.0.0
+ * @since 1.0.0
+ *
+ * @see {@link https://github.com/Agbokoudjo/file_uploader | GitHub Repository}
+ * @see {@link EventDispatcherInterface} for event dispatcher usage
+ */
+declare abstract class HttpFileUploaderEvents {
+    static readonly INITIALIZE_UPLOAD = "initializingUpload";
+    /** Dispatched when upload initialization starts */
+    static readonly INITIALIZE_UPLOAD_STARTED = "initializeUploadStarted";
+    /** Dispatched when upload initialization succeeds */
+    static readonly INITIALIZE_UPLOAD_SUCCESS = "initializeUploadSuccess";
+    /** Dispatched when upload initialization fails */
+    static readonly INITIALIZE_UPLOAD_FAILURE = "initializeUploadFailure";
+    /** Dispatched when a chunk upload starts */
+    static readonly MEDIA_CHUNK_UPLOAD_STARTED = "mediaChunkUploadStarted";
+    /** Dispatched when a chunk is uploaded successfully */
+    static readonly MEDIA_CHUNK_UPLOAD_SUCCESS = "mediaChunkUploadSuccess";
+    /** Dispatched when a chunk upload fails */
+    static readonly MEDIA_CHUNK_UPLOAD_FAILED = "mediaChunkUploadFailed";
+    /** Dispatched when the server returns an HTTP error for a chunk */
+    static readonly MEDIA_CHUNK_UPLOAD_HTTP_ERROR_RESPONSE = "mediaChunkUploadHttpErrorResponse";
+    /** Dispatched to provide the status of a chunk */
+    static readonly MEDIA_CHUNK_UPLOAD_STATUS = "mediaChunkUploadStatus";
+    /** Dispatched when maximum retry attempts are exceeded for a chunk */
+    static readonly MEDIA_CHUNK_UPLOAD_MAXRETRY_EXPIRE = "mediaChunkUploadMaxRetryExpire";
+    /** Dispatched when a chunk upload resumes */
+    static readonly MEDIA_CHUNK_UPLOAD_RESUME = "mediaChunkUploadResume";
+    /** Dispatched when the upload is paused */
+    static readonly UPLOAD_PAUSED = "uploadPaused";
+    /** Dispatched when the upload resumes after being paused */
+    static readonly UPLOAD_RESUMED = "uploadResumed";
+    /** Dispatched when the upload is cancelled */
+    static readonly UPLOAD_CANCELLED = "uploadCancelled";
+    /** Dispatched when the upload state changes */
+    static readonly UPLOAD_STATE_CHANGED = "uploadStateChanged";
+    /** Dispatched when the upload completes successfully */
+    static readonly DOWNLOAD_MEDIA_COMPLETE = "downloadMediaComplete";
+    /** Dispatched when the upload fails completely */
+    static readonly DOWNLOAD_MEDIA_FAILURE = "downloadMediaFailure";
+    /** Dispatched when the upload resumes from a saved state */
+    static readonly DOWNLOAD_MEDIA_RESUME = "downloadMediaResume";
+    static readonly FINALIZE_UPLOAD = "finalizeUpload";
+    static readonly FINALIZE_UPLOAD_FAILURE = "finalizeUploadFailure";
+    /** Dispatched when media metadata is saved successfully */
+    static readonly MEDIA_METADATA_SAVE_SUCCESS = "mediaMetadataSaveSuccess";
+    private constructor();
+}
+
+export { HttpFileUploaderEvents };

package/dist/cjs/events/index.js

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var events_exports = {};
+__export(events_exports, {
+  HttpFileUploaderEvents: () => HttpFileUploaderEvents
+});
+module.exports = __toCommonJS(events_exports);
+__reExport(events_exports, require("./initialize"), module.exports);
+__reExport(events_exports, require("./state"), module.exports);
+__reExport(events_exports, require("./chunk"), module.exports);
+__reExport(events_exports, require("./complete"), module.exports);
+class HttpFileUploaderEvents {
+  static {
+    __name(this, "HttpFileUploaderEvents");
+  }
+  static INITIALIZE_UPLOAD = "initializingUpload";
+  /** Dispatched when upload initialization starts */
+  static INITIALIZE_UPLOAD_STARTED = "initializeUploadStarted";
+  /** Dispatched when upload initialization succeeds */
+  static INITIALIZE_UPLOAD_SUCCESS = "initializeUploadSuccess";
+  /** Dispatched when upload initialization fails */
+  static INITIALIZE_UPLOAD_FAILURE = "initializeUploadFailure";
+  /** Dispatched when a chunk upload starts */
+  static MEDIA_CHUNK_UPLOAD_STARTED = "mediaChunkUploadStarted";
+  /** Dispatched when a chunk is uploaded successfully */
+  static MEDIA_CHUNK_UPLOAD_SUCCESS = "mediaChunkUploadSuccess";
+  /** Dispatched when a chunk upload fails */
+  static MEDIA_CHUNK_UPLOAD_FAILED = "mediaChunkUploadFailed";
+  /** Dispatched when the server returns an HTTP error for a chunk */
+  static MEDIA_CHUNK_UPLOAD_HTTP_ERROR_RESPONSE = "mediaChunkUploadHttpErrorResponse";
+  /** Dispatched to provide the status of a chunk */
+  static MEDIA_CHUNK_UPLOAD_STATUS = "mediaChunkUploadStatus";
+  /** Dispatched when maximum retry attempts are exceeded for a chunk */
+  static MEDIA_CHUNK_UPLOAD_MAXRETRY_EXPIRE = "mediaChunkUploadMaxRetryExpire";
+  /** Dispatched when a chunk upload resumes */
+  static MEDIA_CHUNK_UPLOAD_RESUME = "mediaChunkUploadResume";
+  /** Dispatched when the upload is paused */
+  static UPLOAD_PAUSED = "uploadPaused";
+  /** Dispatched when the upload resumes after being paused */
+  static UPLOAD_RESUMED = "uploadResumed";
+  /** Dispatched when the upload is cancelled */
+  static UPLOAD_CANCELLED = "uploadCancelled";
+  /** Dispatched when the upload state changes */
+  static UPLOAD_STATE_CHANGED = "uploadStateChanged";
+  /** Dispatched when the upload completes successfully */
+  static DOWNLOAD_MEDIA_COMPLETE = "downloadMediaComplete";
+  /** Dispatched when the upload fails completely */
+  static DOWNLOAD_MEDIA_FAILURE = "downloadMediaFailure";
+  /** Dispatched when the upload resumes from a saved state */
+  static DOWNLOAD_MEDIA_RESUME = "downloadMediaResume";
+  static FINALIZE_UPLOAD = "finalizeUpload";
+  static FINALIZE_UPLOAD_FAILURE = "finalizeUploadFailure";
+  /** Dispatched when media metadata is saved successfully */
+  static MEDIA_METADATA_SAVE_SUCCESS = "mediaMetadataSaveSuccess";
+  constructor() {
+    throw new Error("HttpFileUploaderEvents is an abstract class and cannot be instantiated");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpFileUploaderEvents,
+  ...require("./initialize"),
+  ...require("./state"),
+  ...require("./chunk"),
+  ...require("./complete")
+});
+//# sourceMappingURL=index.js.map

package/dist/cjs/events/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/events/index.ts"],"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\n/**\n * HttpFileUploaderEvents - Event Constants for File Upload Operations\n * \n * This abstract class provides a centralized collection of event name constants\n * used throughout the file upload lifecycle. It follows the Symfony event\n * dispatcher pattern, providing a type-safe way to reference events.\n * \n * The events are organized into five categories:\n * - **Initialize Events**: Events related to upload session initialization\n * - **Chunk Upload Events**: Events fired during individual chunk uploads\n * - **Upload State Events**: Events tracking upload state changes (pause, resume, cancel)\n * - **Completion Events**: Events fired when upload completes or fails\n * - **Metadata Events**: Events related to media metadata operations\n * \n * @example\n * ```typescript\n * import { HttpFileUploaderEvents } from '@wlindabla/file_uploader';\n * \n * // Listen to chunk upload success\n * dispatcher.addListener(\n *   HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_SUCCESS,\n *   (event: ChunkUploadSuccessEvent) => {\n *     console.log('Chunk uploaded:', event.progress);\n *   }\n * );\n * \n * // Listen to upload state changes\n * dispatcher.addListener(\n *   HttpFileUploaderEvents.UPLOAD_STATE_CHANGED,\n *   (event: UploadStateChangedEvent) => {\n *     console.log(`State changed: ${event.oldState} → ${event.newState}`);\n *   }\n * );\n * ```\n * \n * @author AGBOKOUDJO Franck <internationaleswebservices@gmail.com>\n * @version 1.0.0\n * @since 1.0.0\n * \n * @see {@link https://github.com/Agbokoudjo/file_uploader | GitHub Repository}\n * @see {@link EventDispatcherInterface} for event dispatcher usage\n */\nexport abstract class HttpFileUploaderEvents {\n\n    static readonly INITIALIZE_UPLOAD = \"initializingUpload\"\n    \n    /** Dispatched when upload initialization starts */\n    static readonly INITIALIZE_UPLOAD_STARTED = \"initializeUploadStarted\";\n\n    /** Dispatched when upload initialization succeeds */\n    static readonly INITIALIZE_UPLOAD_SUCCESS = \"initializeUploadSuccess\";\n\n    /** Dispatched when upload initialization fails */\n    static readonly INITIALIZE_UPLOAD_FAILURE = \"initializeUploadFailure\";\n\n    /** Dispatched when a chunk upload starts */\n    static readonly MEDIA_CHUNK_UPLOAD_STARTED = \"mediaChunkUploadStarted\";\n\n    /** Dispatched when a chunk is uploaded successfully */\n    static readonly MEDIA_CHUNK_UPLOAD_SUCCESS = \"mediaChunkUploadSuccess\";\n\n    /** Dispatched when a chunk upload fails */\n    static readonly MEDIA_CHUNK_UPLOAD_FAILED = \"mediaChunkUploadFailed\";\n\n    /** Dispatched when the server returns an HTTP error for a chunk */\n    static readonly MEDIA_CHUNK_UPLOAD_HTTP_ERROR_RESPONSE = \"mediaChunkUploadHttpErrorResponse\";\n\n    /** Dispatched to provide the status of a chunk */\n    static readonly MEDIA_CHUNK_UPLOAD_STATUS = \"mediaChunkUploadStatus\";\n\n    /** Dispatched when maximum retry attempts are exceeded for a chunk */\n    static readonly MEDIA_CHUNK_UPLOAD_MAXRETRY_EXPIRE = \"mediaChunkUploadMaxRetryExpire\";\n\n    /** Dispatched when a chunk upload resumes */\n    static readonly MEDIA_CHUNK_UPLOAD_RESUME = \"mediaChunkUploadResume\";\n\n    /** Dispatched when the upload is paused */\n    static readonly UPLOAD_PAUSED = \"uploadPaused\";\n\n    /** Dispatched when the upload resumes after being paused */\n    static readonly UPLOAD_RESUMED = \"uploadResumed\";\n\n    /** Dispatched when the upload is cancelled */\n    static readonly UPLOAD_CANCELLED = \"uploadCancelled\";\n\n    /** Dispatched when the upload state changes */\n    static readonly UPLOAD_STATE_CHANGED = \"uploadStateChanged\";\n\n    /** Dispatched when the upload completes successfully */\n    static readonly DOWNLOAD_MEDIA_COMPLETE = \"downloadMediaComplete\";\n\n    /** Dispatched when the upload fails completely */\n    static readonly DOWNLOAD_MEDIA_FAILURE = \"downloadMediaFailure\";\n\n    /** Dispatched when the upload resumes from a saved state */\n    static readonly DOWNLOAD_MEDIA_RESUME = \"downloadMediaResume\";\n\n    static readonly FINALIZE_UPLOAD = \"finalizeUpload\";\n\n    static readonly FINALIZE_UPLOAD_FAILURE = \"finalizeUploadFailure\";\n\n    /** Dispatched when media metadata is saved successfully */\n    static readonly MEDIA_METADATA_SAVE_SUCCESS = \"mediaMetadataSaveSuccess\";\n\n    private constructor() {\n        // This class cannot be instantiated\n        throw new Error('HttpFileUploaderEvents is an abstract class and cannot be instantiated');\n    }\n}\n\nexport * from \"./initialize\"\nexport * from \"./state\";\nexport * from \"./chunk\";\nexport * from \"./complete\";"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAyHA,2BAAc,yBAzHd;AA0HA,2BAAc,oBA1Hd;AA2HA,2BAAc,oBA3Hd;AA4HA,2BAAc,uBA5Hd;AAqDO,MAAe,uBAAuB;AAAA,EArD7C,OAqD6C;AAAA;AAAA;AAAA,EAEzC,OAAgB,oBAAoB;AAAA;AAAA,EAGpC,OAAgB,4BAA4B;AAAA;AAAA,EAG5C,OAAgB,4BAA4B;AAAA;AAAA,EAG5C,OAAgB,4BAA4B;AAAA;AAAA,EAG5C,OAAgB,6BAA6B;AAAA;AAAA,EAG7C,OAAgB,6BAA6B;AAAA;AAAA,EAG7C,OAAgB,4BAA4B;AAAA;AAAA,EAG5C,OAAgB,yCAAyC;AAAA;AAAA,EAGzD,OAAgB,4BAA4B;AAAA;AAAA,EAG5C,OAAgB,qCAAqC;AAAA;AAAA,EAGrD,OAAgB,4BAA4B;AAAA;AAAA,EAG5C,OAAgB,gBAAgB;AAAA;AAAA,EAGhC,OAAgB,iBAAiB;AAAA;AAAA,EAGjC,OAAgB,mBAAmB;AAAA;AAAA,EAGnC,OAAgB,uBAAuB;AAAA;AAAA,EAGvC,OAAgB,0BAA0B;AAAA;AAAA,EAG1C,OAAgB,yBAAyB;AAAA;AAAA,EAGzC,OAAgB,wBAAwB;AAAA,EAExC,OAAgB,kBAAkB;AAAA,EAElC,OAAgB,0BAA0B;AAAA;AAAA,EAG1C,OAAgB,8BAA8B;AAAA,EAEtC,cAAc;AAElB,UAAM,IAAI,MAAM,wEAAwE;AAAA,EAC5F;AACJ;","names":[]}