@wlindabla/file_uploader 1.0.0 → 2.0.1

package/dist/cjs/core/index.js

@@ -0,0 +1,762 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var core_exports = {};
+__export(core_exports, {
+  ChunkedFileUploader: () => ChunkedFileUploader
+});
+module.exports = __toCommonJS(core_exports);
+var import_core = require("@wlindabla/http_client/core");
+var import_types = require("../types");
+var import_utils = require("../utils");
+var import_events = require("../events");
+var import_exceptions = require("../exceptions");
+var import_p_limit = __toESM(require("p-limit"));
+/**
+ * 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}
+ */
+class ChunkedFileUploader {
+  /**
+    * @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;
+    this._file = null;
+    this._endpoints = null;
+    this.isPaused = false;
+    this.startTime = 0;
+    this.uploadedBytes = 0;
+    this.abortController = new AbortController();
+    this.state = import_types.UploadState.IDLE;
+    this.totalChunks = 0;
+    this.percentage = 0;
+    this.uploadedChunks = 0;
+    this.lastUploadedChunkIndex = -1;
+  }
+  _uploadEventDispatcher;
+  uploadResumeData;
+  options;
+  static {
+    __name(this, "ChunkedFileUploader");
+  }
+  _file;
+  _endpoints;
+  isPaused;
+  startTime;
+  uploadedBytes;
+  abortController;
+  state;
+  totalChunks;
+  percentage;
+  uploadedChunks;
+  lastUploadedChunkIndex;
+  /**
+   * 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();
+   * ```
+   */
+  async upload() {
+    this.setState(import_types.UploadState.INITIALIZING);
+    const {
+      maxRetries = 3,
+      config,
+      speedMbps,
+      metadata,
+      headerInitialzingUpload,
+      concurrency = 3
+    } = this.options;
+    let file;
+    try {
+      file = this.file;
+    } catch (error) {
+      throw error;
+    }
+    const fileHash = await import_utils.FileUtils.generateFileHash(this.file);
+    let fileId;
+    try {
+      const initializationEvent = await this._uploadEventDispatcher.dispatchAsync(
+        new import_events.InitializingUploadEvent(
+          {
+            fileHash,
+            fileName: file.name,
+            fileSize: file.size,
+            fileType: file.type,
+            metadata,
+            endpointInit: this.endPointOptions.init,
+            headers: headerInitialzingUpload
+          }
+        ),
+        import_events.HttpFileUploaderEvents.INITIALIZE_UPLOAD
+      );
+      fileId = initializationEvent.mediaId;
+    } catch (error) {
+      this.setState(import_types.UploadState.FAILED);
+      throw error;
+    }
+    this.setState(import_types.UploadState.UPLOADING);
+    this.startTime = Date.now();
+    this.uploadedBytes = 0;
+    this.uploadedChunks = 0;
+    this.lastUploadedChunkIndex = -1;
+    const chunkSize = this.options.chunkSize || import_utils.FileUtils.calculateChunkSize(file.size, speedMbps, config);
+    this.totalChunks = Math.ceil(file.size / chunkSize);
+    try {
+      await this.uploadChunksWithConcurrency(
+        file,
+        chunkSize,
+        fileId,
+        fileHash,
+        maxRetries,
+        concurrency,
+        0
+      );
+      await this.finalizeUpload(fileId, fileHash);
+    } catch (error) {
+      this.handleUploadFailure(error);
+      throw error;
+    }
+  }
+  withFile(file) {
+    if (!file) {
+      throw new Error("File is required");
+    }
+    if (file.size === 0) {
+      throw new Error("Cannot upload empty file");
+    }
+    if (!(file instanceof File) || !(file instanceof Blob)) {
+      throw new TypeError("Expected File or Blob instance");
+    }
+    this._file = file;
+    return this;
+  }
+  withEndpoints(endpoints) {
+    if (!endpoints.init || !endpoints.upload || !endpoints.finalize) {
+      throw new Error("All endpoints (init, upload, finalize) are required");
+    }
+    this._endpoints = endpoints;
+    return this;
+  }
+  get endPointOptions() {
+    if (!this._endpoints) {
+      throw new Error("Endpoint URL is required");
+    }
+    return this._endpoints;
+  }
+  get file() {
+    if (!this._file) {
+      throw new Error(`
+                This operation requires a mandatory file.Did you forget to upload the file?  
+                Use the withFile(file: File|Blob) function of the ChunkedFileUploader ${this} class that you instantiated.
+                `);
+    }
+    return this._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)
+   */
+  async uploadChunksWithConcurrency(file, chunkSize, fileId, fileHash, maxRetries, concurrency, startIndex = 0) {
+    try {
+      const limit = (0, import_p_limit.default)(concurrency);
+      const uploadPromises = [];
+      for (let chunkIndex = startIndex; chunkIndex < this.totalChunks; chunkIndex++) {
+        const limitedUpload = limit(
+          () => this.processChunk(
+            file,
+            chunkIndex,
+            chunkSize,
+            fileId,
+            fileHash,
+            maxRetries
+          )
+        );
+        uploadPromises.push(limitedUpload);
+      }
+      await Promise.all(uploadPromises);
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * 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
+   */
+  async processChunk(file, currentChunkIndex, chunkSize, fileId, fileHash, maxRetries) {
+    try {
+      if (this.abortController.signal.aborted) {
+        this._uploadEventDispatcher.dispatch(
+          new import_events.UploadCancelledEvent(
+            file.name,
+            this.totalChunks,
+            this.uploadedBytes,
+            this.percentage,
+            currentChunkIndex,
+            "Upload cancelled by user",
+            Date.now()
+          ),
+          import_events.HttpFileUploaderEvents.UPLOAD_CANCELLED
+        );
+        return;
+      }
+      while (this.isPaused) {
+        await this.sleep(100);
+      }
+      const start = currentChunkIndex * chunkSize;
+      const end = Math.min(file.size, start + chunkSize);
+      const chunk = file.slice(start, end);
+      const chunkInfo = {
+        index: currentChunkIndex,
+        start,
+        end,
+        size: chunk.size,
+        attempt: 0,
+        status: "pending"
+      };
+      this._uploadEventDispatcher.dispatch(
+        new import_events.UploadChunkStartedEvent(chunkInfo),
+        import_events.HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_STARTED
+      );
+      await this.uploadChunkWithRetry(
+        chunk,
+        chunkInfo,
+        fileId,
+        fileHash,
+        this.totalChunks,
+        maxRetries
+      );
+      if (this.options.autoSave) {
+        await this.saveResumeData(fileId, chunkSize);
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+  async uploadChunkWithRetry(chunk, chunkInfo, fileId, fileHash, totalChunks, maxRetries) {
+    let success = false;
+    let lastError = null;
+    for (let attempt = 0; attempt < maxRetries && !success; attempt++) {
+      chunkInfo.attempt = attempt + 1;
+      chunkInfo.status = "uploading";
+      try {
+        const response = await this.uploadChunk(chunk, chunkInfo, fileId, fileHash, totalChunks);
+        success = true;
+        chunkInfo.status = "success";
+        this.updateProgress(chunk.size, chunkInfo.index);
+        this.notifyProgress(
+          this.uploadedChunks,
+          totalChunks,
+          this.file.size,
+          response
+        );
+        return;
+      } catch (error) {
+        if (error instanceof import_exceptions.ChunkUploadHttpErrorException) {
+          this._uploadEventDispatcher.dispatch(
+            new import_events.ChunkUploadHttpErrorResponseEvent(
+              error.errorPayload,
+              error.statusResponse,
+              this.endPointOptions.upload,
+              chunkInfo
+            ),
+            import_events.HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_HTTP_ERROR_RESPONSE
+          );
+        }
+        lastError = error;
+        chunkInfo.status = "error";
+        const chunkError = {
+          chunk: chunkInfo,
+          error: lastError,
+          attempt: attempt + 1,
+          willRetry: attempt < maxRetries - 1
+        };
+        if (error instanceof import_core.HttpFetchError) {
+          this._uploadEventDispatcher.dispatch(chunkError, import_events.HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_FAILED);
+        }
+        if (attempt < maxRetries - 1) {
+          const delay = Math.pow(2, attempt) * 1e3;
+          await this.sleep(delay);
+          console.info(`Retry #${attempt + 2} in ${delay / 1e3}s...`);
+        }
+      }
+    }
+    if (!success) {
+      const fileUploadChunkError = new import_exceptions.FileUploadChunkError(
+        `Failed to upload chunk ${chunkInfo.index} after ${maxRetries} attempts`,
+        {
+          chunk: chunkInfo,
+          error: lastError,
+          attempt: maxRetries,
+          willRetry: false
+        }
+      );
+      this._uploadEventDispatcher.dispatch(
+        fileUploadChunkError,
+        import_events.HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_MAXRETRY_EXPIRE
+      );
+      throw fileUploadChunkError;
+    }
+  }
+  async uploadChunk(chunk, chunkInfo, mediaIdFromServer, fileHash, totalChunks) {
+    const media = this.file;
+    const chunkFormData = (0, import_utils.createChunkFormData)(
+      chunk,
+      {
+        chunkIndex: chunkInfo.index,
+        mediaId: mediaIdFromServer,
+        fileSize: media.size,
+        fileName: media.name,
+        fileHash,
+        totalChunks
+      }
+    );
+    try {
+      const response_of_server = await (0, import_core.safeFetch)({
+        url: this.endPointOptions.upload,
+        headers: this.options.headers,
+        data: chunkFormData,
+        methodSend: "POST",
+        responseType: "json",
+        timeout: this.options.timeout ?? 6e4,
+        retryCount: 2,
+        retryOnStatusCode: false,
+        signal: this.createChunkAbortSignal()
+      });
+      const statusResponse = response_of_server.status;
+      if (response_of_server.failed) {
+        throw new import_exceptions.ChunkUploadHttpErrorException(response_of_server.data, statusResponse);
+      }
+      return response_of_server;
+    } catch (error) {
+      throw error;
+    }
+  }
+  createChunkAbortSignal() {
+    const chunkController = new AbortController();
+    this.abortController.signal.addEventListener("abort", () => {
+      chunkController.abort();
+    });
+    return chunkController.signal;
+  }
+  notifyProgress(uploadedChunks, totalChunks, totalBytes, httpResponse) {
+    const elapsed = Math.max((Date.now() - this.startTime) / 1e3, 0.1);
+    const speed = this.uploadedBytes / elapsed;
+    const remainingBytes = totalBytes - this.uploadedBytes;
+    const estimatedTimeRemaining = uploadedChunks < 2 ? null : remainingBytes / speed;
+    this.percentage = Math.round(this.uploadedBytes / totalBytes * 100);
+    const progress = {
+      uploadedChunks,
+      totalChunks,
+      uploadedBytes: this.uploadedBytes,
+      totalBytes,
+      percentage: this.percentage,
+      currentChunk: uploadedChunks,
+      speed,
+      // bytes/seconde
+      estimatedTimeRemaining,
+      // secondes (ou null)
+      elapsed
+      // secondes écoulées
+    };
+    this._uploadEventDispatcher.dispatch(
+      new import_events.UploadProgressEvent(
+        progress,
+        httpResponse.data,
+        httpResponse.status
+      )
+    );
+    console.info(
+      `Progress: ${this.percentage}% | Speed: ${import_utils.FileUtils.formatBytes(speed)}/s | ETA: ${estimatedTimeRemaining ? import_utils.FileUtils.formatDuration(estimatedTimeRemaining) : "Calculating..."}`
+    );
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * 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
+   */
+  async saveResumeData(fileId, chunkSize) {
+    const data = {
+      fileId,
+      fileName: this.file.name,
+      fileSize: this.file.size,
+      uploadedChunks: this.uploadedChunks,
+      lastChunkIndex: this.lastUploadedChunkIndex,
+      lastBytePosition: this.uploadedBytes,
+      chunkSize,
+      concurrency: this.options.concurrency || 3
+    };
+    await this.uploadResumeData.setItem(`upload_${this.file.name}`, data);
+    console.info(
+      `Resume data saved: ${this.uploadedChunks}/${Math.ceil(this.file.size / chunkSize)} chunks, last chunk index: ${this.lastUploadedChunkIndex}`
+    );
+    return data;
+  }
+  setState(newState) {
+    const oldState = this.state;
+    this.state = newState;
+    this._uploadEventDispatcher.dispatch(
+      new import_events.UploadStateChangedEvent(
+        oldState,
+        newState,
+        Date.now()
+      ),
+      import_events.HttpFileUploaderEvents.UPLOAD_STATE_CHANGED
+    );
+  }
+  getState() {
+    return this.state;
+  }
+  handleUploadFailure(error) {
+    this.setState(import_types.UploadState.FAILED);
+    this._uploadEventDispatcher.dispatch(error, import_events.HttpFileUploaderEvents.DOWNLOAD_MEDIA_FAILURE);
+    console.error("Upload failed:", error);
+  }
+  cancel() {
+    this.abortController.abort();
+    this.setState(import_types.UploadState.CANCELLED);
+  }
+  pause() {
+    this.isPaused = true;
+    this.setState(import_types.UploadState.PAUSED);
+    this._uploadEventDispatcher.dispatch(
+      new import_events.UploadPausedEvent(
+        this.file.name,
+        this.totalChunks,
+        this.uploadedBytes,
+        this.percentage,
+        Date.now()
+      ),
+      import_events.HttpFileUploaderEvents.UPLOAD_PAUSED
+    );
+  }
+  resume() {
+    this.isPaused = false;
+    this.setState(import_types.UploadState.UPLOADING);
+    this._uploadEventDispatcher.dispatch(
+      new import_events.UploadResumedEvent(
+        this.file.name,
+        this.totalChunks,
+        this.uploadedBytes,
+        this.percentage
+      ),
+      import_events.HttpFileUploaderEvents.UPLOAD_RESUMED
+    );
+  }
+  /**
+  * Load previously saved resume data
+  * 
+  * @param fileName - Name of the file to resume
+  * @returns Resume data or null if not found
+  */
+  async loadResumeData(fileName) {
+    try {
+      const data = await this.uploadResumeData.getItem(`upload_${fileName}`);
+      if (data) {
+        console.info(
+          `Resume data loaded: ${data.uploadedChunks} chunks uploaded, last index: ${data.lastChunkIndex}`
+        );
+      }
+      return data;
+    } catch (error) {
+      console.warn(`No resume data found for ${fileName}`);
+      return null;
+    }
+  }
+  /**
+  * Resume upload from saved state
+  * 
+  * @param resumeData - Previously saved resume data
+  * @returns Upload result
+  */
+  async resumeUpload(resumeData) {
+    const __message = `Resuming upload from chunk ${resumeData.lastChunkIndex + 1} (${resumeData.uploadedChunks} chunks already uploaded)`;
+    this.uploadedBytes = resumeData.lastBytePosition;
+    this.uploadedChunks = resumeData.uploadedChunks;
+    this.lastUploadedChunkIndex = resumeData.lastChunkIndex;
+    const assumedSpeed = 5e5;
+    const timeAlreadySpent = resumeData.lastBytePosition / assumedSpeed;
+    this.startTime = Date.now() - timeAlreadySpent * 1e3;
+    const { maxRetries = 3 } = this.options;
+    const fileHash = await import_utils.FileUtils.generateFileHash(this.file);
+    const chunkSize = resumeData.chunkSize;
+    this.totalChunks = Math.ceil(this.file.size / chunkSize);
+    try {
+      this._uploadEventDispatcher.dispatch(
+        new import_events.ResumeUploadEvent(resumeData, __message),
+        import_events.HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_RESUME
+      );
+      await this.uploadChunksWithConcurrency(
+        this.file,
+        chunkSize,
+        resumeData.fileId,
+        fileHash,
+        maxRetries,
+        resumeData.concurrency,
+        resumeData.lastChunkIndex + 1
+      );
+      await this.finalizeUpload(resumeData.fileId, fileHash);
+    } catch (error) {
+      this.handleUploadFailure(error);
+      throw error;
+    }
+  }
+  updateProgress(chunkSize, chunkIndex) {
+    this.uploadedBytes += chunkSize;
+    this.uploadedChunks++;
+    this.lastUploadedChunkIndex = Math.max(this.lastUploadedChunkIndex, chunkIndex);
+  }
+  async finalizeUpload(mediaId, fileHash) {
+    try {
+      const finalizeUploadEvent = await this._uploadEventDispatcher.dispatchAsync(
+        new import_events.FinalizeUploadEvent(
+          this.endPointOptions.finalize,
+          mediaId,
+          fileHash,
+          this.options.headerFinalezingUpload
+        ),
+        import_events.HttpFileUploaderEvents.FINALIZE_UPLOAD
+      );
+      this.setState(import_types.UploadState.FINALIZING);
+      const duration = (Date.now() - this.startTime) / 1e3;
+      const uploadResult = {
+        success: true,
+        finalizeUploadResponse: finalizeUploadEvent.hasResponse() ? finalizeUploadEvent.getResponse() : null,
+        totalChunks: this.totalChunks,
+        totalBytes: this.file.size,
+        duration,
+        averageSpeed: this.file.size / duration,
+        fileId: mediaId
+      };
+      this.setState(import_types.UploadState.COMPLETED);
+      this._uploadEventDispatcher.dispatch(
+        new import_events.UploadMediaCompleteEvent(uploadResult),
+        import_events.HttpFileUploaderEvents.DOWNLOAD_MEDIA_COMPLETE
+      );
+    } catch (error) {
+      throw error;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChunkedFileUploader
+});
+//# sourceMappingURL=index.js.map