@wlindabla/file_uploader 1.0.0

package/dist/core/index.js

@@ -0,0 +1,724 @@
+'use strict';
+
+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) {
+    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 = types.UploadState.IDLE;
+    this.totalChunks = 0;
+    this.percentage = 0;
+    this.uploadedChunks = 0;
+    this.lastUploadedChunkIndex = -1;
+  }
+  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(types.UploadState.INITIALIZING);
+    const {
+      maxRetries = 3,
+      config,
+      speedMbps,
+      metadata,
+      headerInitialzingUpload,
+      concurrency = 3
+    } = this.options;
+    const file = this.file;
+    const fileHash = await utils.FileUtils.generateFileHash(file);
+    let fileId;
+    try {
+      const initializationEvent = this._uploadEventDispatcher.dispatch(
+        new events.InitializingUploadEvent(
+          {
+            fileHash,
+            fileName: this.file.name,
+            fileSize: this.file.size,
+            fileType: this.file.type,
+            metadata,
+            endpointInit: this.endPointOptions.init,
+            headers: headerInitialzingUpload
+          }
+        ),
+        events.HttpFileUploaderEvents.INITIALIZE_UPLOAD
+      );
+      fileId = initializationEvent.mediaId;
+    } catch (error) {
+      this.setState(types.UploadState.FAILED);
+      throw error;
+    }
+    this.setState(types.UploadState.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);
+    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 = pLimit__default.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 events.UploadCancelledEvent(
+            file.name,
+            this.totalChunks,
+            this.uploadedBytes,
+            this.percentage,
+            currentChunkIndex,
+            "Upload cancelled by user",
+            Date.now()
+          ),
+          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 events.UploadChunkStartedEvent(chunkInfo),
+        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 exceptions.ChunkUploadHttpErrorException) {
+          this._uploadEventDispatcher.dispatch(
+            new events.ChunkUploadHttpErrorResponseEvent(
+              error.errorPayload,
+              error.statusResponse,
+              this.endPointOptions.upload,
+              chunkInfo
+            ),
+            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 http_client.HttpFetchError) {
+          this._uploadEventDispatcher.dispatch(chunkError, 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 exceptions.FileUploadChunkError(
+        `Failed to upload chunk ${chunkInfo.index} after ${maxRetries} attempts`,
+        {
+          chunk: chunkInfo,
+          error: lastError,
+          attempt: maxRetries,
+          willRetry: false
+        }
+      );
+      this._uploadEventDispatcher.dispatch(
+        fileUploadChunkError,
+        events.HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_MAXRETRY_EXPIRE
+      );
+      throw fileUploadChunkError;
+    }
+  }
+  async uploadChunk(chunk, chunkInfo, mediaIdFromServer, fileHash, totalChunks) {
+    const media = this.file;
+    const chunkFormData = utils.createChunkFormData(
+      chunk,
+      {
+        chunkIndex: chunkInfo.index,
+        mediaId: mediaIdFromServer,
+        fileSize: media.size,
+        fileName: media.name,
+        fileHash,
+        totalChunks
+      }
+    );
+    try {
+      const response_of_server = await http_client.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 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 events.UploadProgressEvent(
+        progress,
+        httpResponse.data,
+        httpResponse.status
+      )
+    );
+    console.info(
+      `Progress: ${this.percentage}% | Speed: ${utils.FileUtils.formatBytes(speed)}/s | ETA: ${estimatedTimeRemaining ? 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 events.UploadStateChangedEvent(
+        oldState,
+        newState,
+        Date.now()
+      ),
+      events.HttpFileUploaderEvents.UPLOAD_STATE_CHANGED
+    );
+  }
+  getState() {
+    return this.state;
+  }
+  handleUploadFailure(error) {
+    this.setState(types.UploadState.FAILED);
+    this._uploadEventDispatcher.dispatch(error, events.HttpFileUploaderEvents.DOWNLOAD_MEDIA_FAILURE);
+    console.error("Upload failed:", error);
+  }
+  cancel() {
+    this.abortController.abort();
+    this.setState(types.UploadState.CANCELLED);
+  }
+  pause() {
+    this.isPaused = true;
+    this.setState(types.UploadState.PAUSED);
+    this._uploadEventDispatcher.dispatch(
+      new events.UploadPausedEvent(
+        this.file.name,
+        this.totalChunks,
+        this.uploadedBytes,
+        this.percentage,
+        Date.now()
+      ),
+      events.HttpFileUploaderEvents.UPLOAD_PAUSED
+    );
+  }
+  resume() {
+    this.isPaused = false;
+    this.setState(types.UploadState.UPLOADING);
+    this._uploadEventDispatcher.dispatch(
+      new events.UploadResumedEvent(
+        this.file.name,
+        this.totalChunks,
+        this.uploadedBytes,
+        this.percentage
+      ),
+      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 utils.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
+      );
+      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 = this._uploadEventDispatcher.dispatch(
+        new events.FinalizeUploadEvent(
+          this.endPointOptions.finalize,
+          mediaId,
+          fileHash,
+          this.options.headerFinalezingUpload
+        ),
+        events.HttpFileUploaderEvents.FINALIZE_UPLOAD
+      );
+      this.setState(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(types.UploadState.COMPLETED);
+      this._uploadEventDispatcher.dispatch(
+        new events.UploadMediaCompleteEvent(uploadResult),
+        events.HttpFileUploaderEvents.DOWNLOAD_MEDIA_COMPLETE
+      );
+    } catch (error) {
+      throw error;
+    }
+  }
+}
+
+exports.ChunkedFileUploader = ChunkedFileUploader;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map