@wlindabla/file_uploader 1.0.0 → 2.0.1

package/dist/{core/index.js → esm/chunk-TONVXBLH.js}

@@ -1,180 +1,21 @@
-'use strict';
+import { ChunkUploadHttpErrorException, FileUploadChunkError } from './chunk-NXYS73I4.js';
+import { FileUtils, createChunkFormData } from './chunk-MFYC4PBP.js';
+import { HttpFileUploaderEvents } from './chunk-JDL3U4OX.js';
+import { UploadChunkStartedEvent, ChunkUploadHttpErrorResponseEvent } from './chunk-LD2DWZRJ.js';
+import { ResumeUploadEvent, FinalizeUploadEvent, UploadMediaCompleteEvent } from './chunk-BNMI7DW3.js';
+import { InitializingUploadEvent } from './chunk-3JTTZCSQ.js';
+import { UploadCancelledEvent, UploadProgressEvent, UploadStateChangedEvent, UploadPausedEvent, UploadResumedEvent } from './chunk-6225YMFE.js';
+import { __name } from './chunk-7QVYU63E.js';
+import { HttpFetchError, safeFetch } from '@wlindabla/http_client/core';
+import pLimit from 'p-limit';
 
-var event_dispatcher = require('@wlindabla/event_dispatcher');
-var http_client = require('@wlindabla/http_client');
-var types = require('../types');
-var utils = require('../utils');
-var events = require('../events');
-var exceptions = require('../exceptions');
-var pLimit = require('p-limit');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var pLimit__default = /*#__PURE__*/_interopDefault(pLimit);
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-/**
- * 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}
- */
-class ChunkedFileUploader {
-  constructor(_uploadEventDispatcher = new event_dispatcher.BrowserEventDispatcher(), uploadResumeData, options) {
+var ChunkedFileUploader = class {
+  /**
+    * @param  _uploadEventDispatcher: new BrowserEventDispatcher(), //or new NodeJSEventDispatcher() if you have an environment NodeJs
+    * @param uploadResumeData: UploadResumeCacheInterface
+    * @param options: UploadOptions
+   */
+  constructor(_uploadEventDispatcher, uploadResumeData, options) {
     this._uploadEventDispatcher = _uploadEventDispatcher;
     this.uploadResumeData = uploadResumeData;
     this.options = options;
@@ -184,12 +25,15 @@ class ChunkedFileUploader {
     this.startTime = 0;
     this.uploadedBytes = 0;
     this.abortController = new AbortController();
-    this.state = types.UploadState.IDLE;
+    this.state = "idle" /* IDLE */;
     this.totalChunks = 0;
     this.percentage = 0;
     this.uploadedChunks = 0;
     this.lastUploadedChunkIndex = -1;
   }
+  _uploadEventDispatcher;
+  uploadResumeData;
+  options;
   static {
     __name(this, "ChunkedFileUploader");
   }
@@ -223,7 +67,7 @@ class ChunkedFileUploader {
    * ```
    */
   async upload() {
-    this.setState(types.UploadState.INITIALIZING);
+    this.setState("initializing" /* INITIALIZING */);
     const {
       maxRetries = 3,
       config,
@@ -232,35 +76,40 @@ class ChunkedFileUploader {
       headerInitialzingUpload,
       concurrency = 3
     } = this.options;
-    const file = this.file;
-    const fileHash = await utils.FileUtils.generateFileHash(file);
+    let file;
+    try {
+      file = this.file;
+    } catch (error) {
+      throw error;
+    }
+    const fileHash = await FileUtils.generateFileHash(this.file);
     let fileId;
     try {
-      const initializationEvent = this._uploadEventDispatcher.dispatch(
-        new events.InitializingUploadEvent(
+      const initializationEvent = await this._uploadEventDispatcher.dispatchAsync(
+        new InitializingUploadEvent(
           {
             fileHash,
-            fileName: this.file.name,
-            fileSize: this.file.size,
-            fileType: this.file.type,
+            fileName: file.name,
+            fileSize: file.size,
+            fileType: file.type,
             metadata,
             endpointInit: this.endPointOptions.init,
             headers: headerInitialzingUpload
           }
         ),
-        events.HttpFileUploaderEvents.INITIALIZE_UPLOAD
+        HttpFileUploaderEvents.INITIALIZE_UPLOAD
       );
       fileId = initializationEvent.mediaId;
     } catch (error) {
-      this.setState(types.UploadState.FAILED);
+      this.setState("failed" /* FAILED */);
       throw error;
     }
-    this.setState(types.UploadState.UPLOADING);
+    this.setState("uploading" /* UPLOADING */);
     this.startTime = Date.now();
     this.uploadedBytes = 0;
     this.uploadedChunks = 0;
     this.lastUploadedChunkIndex = -1;
-    const chunkSize = this.options.chunkSize || utils.FileUtils.calculateChunkSize(file.size, speedMbps, config);
+    const chunkSize = this.options.chunkSize || FileUtils.calculateChunkSize(file.size, speedMbps, config);
     this.totalChunks = Math.ceil(file.size / chunkSize);
     try {
       await this.uploadChunksWithConcurrency(
@@ -325,7 +174,7 @@ class ChunkedFileUploader {
    */
   async uploadChunksWithConcurrency(file, chunkSize, fileId, fileHash, maxRetries, concurrency, startIndex = 0) {
     try {
-      const limit = pLimit__default.default(concurrency);
+      const limit = pLimit(concurrency);
       const uploadPromises = [];
       for (let chunkIndex = startIndex; chunkIndex < this.totalChunks; chunkIndex++) {
         const limitedUpload = limit(
@@ -362,7 +211,7 @@ class ChunkedFileUploader {
     try {
       if (this.abortController.signal.aborted) {
         this._uploadEventDispatcher.dispatch(
-          new events.UploadCancelledEvent(
+          new UploadCancelledEvent(
             file.name,
             this.totalChunks,
             this.uploadedBytes,
@@ -371,7 +220,7 @@ class ChunkedFileUploader {
             "Upload cancelled by user",
             Date.now()
           ),
-          events.HttpFileUploaderEvents.UPLOAD_CANCELLED
+          HttpFileUploaderEvents.UPLOAD_CANCELLED
         );
         return;
       }
@@ -390,8 +239,8 @@ class ChunkedFileUploader {
         status: "pending"
       };
       this._uploadEventDispatcher.dispatch(
-        new events.UploadChunkStartedEvent(chunkInfo),
-        events.HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_STARTED
+        new UploadChunkStartedEvent(chunkInfo),
+        HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_STARTED
       );
       await this.uploadChunkWithRetry(
         chunk,
@@ -427,15 +276,15 @@ class ChunkedFileUploader {
         );
         return;
       } catch (error) {
-        if (error instanceof exceptions.ChunkUploadHttpErrorException) {
+        if (error instanceof ChunkUploadHttpErrorException) {
           this._uploadEventDispatcher.dispatch(
-            new events.ChunkUploadHttpErrorResponseEvent(
+            new ChunkUploadHttpErrorResponseEvent(
               error.errorPayload,
               error.statusResponse,
               this.endPointOptions.upload,
               chunkInfo
             ),
-            events.HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_HTTP_ERROR_RESPONSE
+            HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_HTTP_ERROR_RESPONSE
           );
         }
         lastError = error;
@@ -446,8 +295,8 @@ class ChunkedFileUploader {
           attempt: attempt + 1,
           willRetry: attempt < maxRetries - 1
         };
-        if (error instanceof http_client.HttpFetchError) {
-          this._uploadEventDispatcher.dispatch(chunkError, events.HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_FAILED);
+        if (error instanceof HttpFetchError) {
+          this._uploadEventDispatcher.dispatch(chunkError, HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_FAILED);
         }
         if (attempt < maxRetries - 1) {
           const delay = Math.pow(2, attempt) * 1e3;
@@ -457,7 +306,7 @@ class ChunkedFileUploader {
       }
     }
     if (!success) {
-      const fileUploadChunkError = new exceptions.FileUploadChunkError(
+      const fileUploadChunkError = new FileUploadChunkError(
         `Failed to upload chunk ${chunkInfo.index} after ${maxRetries} attempts`,
         {
           chunk: chunkInfo,
@@ -468,14 +317,14 @@ class ChunkedFileUploader {
       );
       this._uploadEventDispatcher.dispatch(
         fileUploadChunkError,
-        events.HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_MAXRETRY_EXPIRE
+        HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_MAXRETRY_EXPIRE
       );
       throw fileUploadChunkError;
     }
   }
   async uploadChunk(chunk, chunkInfo, mediaIdFromServer, fileHash, totalChunks) {
     const media = this.file;
-    const chunkFormData = utils.createChunkFormData(
+    const chunkFormData = createChunkFormData(
       chunk,
       {
         chunkIndex: chunkInfo.index,
@@ -487,7 +336,7 @@ class ChunkedFileUploader {
       }
     );
     try {
-      const response_of_server = await http_client.safeFetch({
+      const response_of_server = await safeFetch({
         url: this.endPointOptions.upload,
         headers: this.options.headers,
         data: chunkFormData,
@@ -500,7 +349,7 @@ class ChunkedFileUploader {
       });
       const statusResponse = response_of_server.status;
       if (response_of_server.failed) {
-        throw new exceptions.ChunkUploadHttpErrorException(response_of_server.data, statusResponse);
+        throw new ChunkUploadHttpErrorException(response_of_server.data, statusResponse);
       }
       return response_of_server;
     } catch (error) {
@@ -535,14 +384,14 @@ class ChunkedFileUploader {
       // secondes écoulées
     };
     this._uploadEventDispatcher.dispatch(
-      new events.UploadProgressEvent(
+      new UploadProgressEvent(
         progress,
         httpResponse.data,
         httpResponse.status
       )
     );
     console.info(
-      `Progress: ${this.percentage}% | Speed: ${utils.FileUtils.formatBytes(speed)}/s | ETA: ${estimatedTimeRemaining ? utils.FileUtils.formatDuration(estimatedTimeRemaining) : "Calculating..."}`
+      `Progress: ${this.percentage}% | Speed: ${FileUtils.formatBytes(speed)}/s | ETA: ${estimatedTimeRemaining ? FileUtils.formatDuration(estimatedTimeRemaining) : "Calculating..."}`
     );
   }
   sleep(ms) {
@@ -576,51 +425,51 @@ class ChunkedFileUploader {
     const oldState = this.state;
     this.state = newState;
     this._uploadEventDispatcher.dispatch(
-      new events.UploadStateChangedEvent(
+      new UploadStateChangedEvent(
         oldState,
         newState,
         Date.now()
       ),
-      events.HttpFileUploaderEvents.UPLOAD_STATE_CHANGED
+      HttpFileUploaderEvents.UPLOAD_STATE_CHANGED
     );
   }
   getState() {
     return this.state;
   }
   handleUploadFailure(error) {
-    this.setState(types.UploadState.FAILED);
-    this._uploadEventDispatcher.dispatch(error, events.HttpFileUploaderEvents.DOWNLOAD_MEDIA_FAILURE);
+    this.setState("failed" /* FAILED */);
+    this._uploadEventDispatcher.dispatch(error, HttpFileUploaderEvents.DOWNLOAD_MEDIA_FAILURE);
     console.error("Upload failed:", error);
   }
   cancel() {
     this.abortController.abort();
-    this.setState(types.UploadState.CANCELLED);
+    this.setState("cancelled" /* CANCELLED */);
   }
   pause() {
     this.isPaused = true;
-    this.setState(types.UploadState.PAUSED);
+    this.setState("paused" /* PAUSED */);
     this._uploadEventDispatcher.dispatch(
-      new events.UploadPausedEvent(
+      new UploadPausedEvent(
         this.file.name,
         this.totalChunks,
         this.uploadedBytes,
         this.percentage,
         Date.now()
       ),
-      events.HttpFileUploaderEvents.UPLOAD_PAUSED
+      HttpFileUploaderEvents.UPLOAD_PAUSED
     );
   }
   resume() {
     this.isPaused = false;
-    this.setState(types.UploadState.UPLOADING);
+    this.setState("uploading" /* UPLOADING */);
     this._uploadEventDispatcher.dispatch(
-      new events.UploadResumedEvent(
+      new UploadResumedEvent(
         this.file.name,
         this.totalChunks,
         this.uploadedBytes,
         this.percentage
       ),
-      events.HttpFileUploaderEvents.UPLOAD_RESUMED
+      HttpFileUploaderEvents.UPLOAD_RESUMED
     );
   }
   /**
@@ -658,13 +507,13 @@ class ChunkedFileUploader {
     const timeAlreadySpent = resumeData.lastBytePosition / assumedSpeed;
     this.startTime = Date.now() - timeAlreadySpent * 1e3;
     const { maxRetries = 3 } = this.options;
-    const fileHash = await utils.FileUtils.generateFileHash(this.file);
+    const fileHash = await FileUtils.generateFileHash(this.file);
     const chunkSize = resumeData.chunkSize;
     this.totalChunks = Math.ceil(this.file.size / chunkSize);
     try {
       this._uploadEventDispatcher.dispatch(
-        new events.ResumeUploadEvent(resumeData, __message),
-        events.HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_RESUME
+        new ResumeUploadEvent(resumeData, __message),
+        HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_RESUME
       );
       await this.uploadChunksWithConcurrency(
         this.file,
@@ -688,16 +537,16 @@ class ChunkedFileUploader {
   }
   async finalizeUpload(mediaId, fileHash) {
     try {
-      const finalizeUploadEvent = this._uploadEventDispatcher.dispatch(
-        new events.FinalizeUploadEvent(
+      const finalizeUploadEvent = await this._uploadEventDispatcher.dispatchAsync(
+        new FinalizeUploadEvent(
           this.endPointOptions.finalize,
           mediaId,
           fileHash,
           this.options.headerFinalezingUpload
         ),
-        events.HttpFileUploaderEvents.FINALIZE_UPLOAD
+        HttpFileUploaderEvents.FINALIZE_UPLOAD
       );
-      this.setState(types.UploadState.FINALIZING);
+      this.setState("finalizing" /* FINALIZING */);
       const duration = (Date.now() - this.startTime) / 1e3;
       const uploadResult = {
         success: true,
@@ -708,17 +557,176 @@ class ChunkedFileUploader {
         averageSpeed: this.file.size / duration,
         fileId: mediaId
       };
-      this.setState(types.UploadState.COMPLETED);
+      this.setState("completed" /* COMPLETED */);
       this._uploadEventDispatcher.dispatch(
-        new events.UploadMediaCompleteEvent(uploadResult),
-        events.HttpFileUploaderEvents.DOWNLOAD_MEDIA_COMPLETE
+        new UploadMediaCompleteEvent(uploadResult),
+        HttpFileUploaderEvents.DOWNLOAD_MEDIA_COMPLETE
       );
     } catch (error) {
       throw error;
     }
   }
-}
+};
+/**
+ * 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   2.0.1
+ * @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}
+ */
 
-exports.ChunkedFileUploader = ChunkedFileUploader;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export { ChunkedFileUploader };
+//# sourceMappingURL=chunk-TONVXBLH.js.map
+//# sourceMappingURL=chunk-TONVXBLH.js.map