@wlindabla/file_uploader 1.0.0 → 2.0.0

package/dist/cjs/subscribers/index.js

@@ -0,0 +1,187 @@
+"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 subscribers_exports = {};
+__export(subscribers_exports, {
+  FinalizeUploadSubscriber: () => FinalizeUploadSubscriber,
+  InitializeUploadSubscriber: () => InitializeUploadSubscriber
+});
+module.exports = __toCommonJS(subscribers_exports);
+var import_events = require("../events");
+var import_core = require("@wlindabla/http_client/core");
+var import_exceptions = require("../exceptions");
+class InitializeUploadSubscriber {
+  constructor(eventDispatcher) {
+    this.eventDispatcher = eventDispatcher;
+  }
+  eventDispatcher;
+  static {
+    __name(this, "InitializeUploadSubscriber");
+  }
+  getSubscribedEvents() {
+    return {
+      [import_events.HttpFileUploaderEvents.INITIALIZE_UPLOAD]: { listener: "onInitializeUpload", priority: 100 }
+    };
+  }
+  /**
+  * Initializes upload session with the server.
+  * 
+  * @param fileHash - SHA-256 hash of the file (first 1MB)
+  * @returns Session ID from server, or null if initialization failed
+  * @throws {FileUploadInitializationError} If server returns error or network fails
+  */
+  async onInitializeUpload(event) {
+    event.stopPropagation();
+    const initialzeUploadRequestOptions = event.initUploadOptions;
+    this.eventDispatcher.dispatch(
+      new import_events.InitializeUploadStartedEvent(
+        initialzeUploadRequestOptions.fileName,
+        initialzeUploadRequestOptions.fileSize,
+        initialzeUploadRequestOptions.fileHash
+      ),
+      import_events.HttpFileUploaderEvents.INITIALIZE_UPLOAD_STARTED
+    );
+    try {
+      const response = await (0, import_core.safeFetch)({
+        url: initialzeUploadRequestOptions.endpointInit,
+        methodSend: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...initialzeUploadRequestOptions.headers
+        },
+        data: {
+          fileName: initialzeUploadRequestOptions.fileName,
+          fileSize: initialzeUploadRequestOptions.fileSize,
+          fileHash: initialzeUploadRequestOptions.fileHash,
+          fileType: initialzeUploadRequestOptions.fileType,
+          metadata: initialzeUploadRequestOptions.metadata
+        },
+        responseType: "json",
+        retryCount: 3,
+        retryOnStatusCode: true,
+        timeout: 45e3
+      });
+      const status = response.status;
+      if (response.failed) {
+        console.error(`Initialize upload failed (HTTP ${status}):`, response);
+        const errorUploadFailure = new import_exceptions.InitializeUploadFailureException(
+          response,
+          `Server returned error: HTTP ${response.status}`
+        );
+        this.eventDispatcher.dispatch(
+          new import_events.InitializeUploadFailureEvent(
+            errorUploadFailure,
+            status,
+            response.data
+          ),
+          import_events.HttpFileUploaderEvents.INITIALIZE_UPLOAD_FAILURE
+        );
+        throw errorUploadFailure;
+      }
+      const responseData = response.data;
+      if (!responseData || typeof responseData !== "object") {
+        const validationError = "Invalid server response: expected object, got " + typeof responseData;
+        console.error("Invalid response structure:", responseData);
+        const err = new import_exceptions.InitializeUploadFailureException(
+          responseData,
+          validationError
+        );
+        throw err;
+      }
+      let sessionId = responseData.mediaId || responseData.mediaIdFromServer || responseData.sessionId || responseData.uploadId;
+      if (!sessionId) {
+        const missingKeyError = 'Server response missing required field: "mediaId","mediaIdFromServer", "sessionId", or "uploadId"';
+        console.error("Missing session ID in response:", responseData);
+        const err = new import_exceptions.InitializeUploadFailureException(
+          responseData,
+          missingKeyError
+        );
+        throw err;
+      }
+      if (typeof sessionId === "number") {
+        sessionId = sessionId.toString();
+      }
+      event.setMediaId(sessionId);
+      this.eventDispatcher.dispatch(
+        new import_events.InitializeUploadSuccessEvent(
+          status,
+          sessionId,
+          responseData
+        ),
+        import_events.HttpFileUploaderEvents.INITIALIZE_UPLOAD_SUCCESS
+      );
+    } catch (error) {
+      if (error instanceof import_core.HttpFetchError) {
+        this.eventDispatcher.dispatch(
+          new import_events.InitializeUploadFailureEvent(
+            error instanceof Error ? error : new Error(String(error))
+          ),
+          import_events.HttpFileUploaderEvents.INITIALIZE_UPLOAD_FAILURE
+        );
+        return;
+      }
+      console.error("Initialize upload exception:", error);
+      throw error;
+    }
+  }
+}
+class FinalizeUploadSubscriber {
+  constructor(eventDispatcher) {
+    this.eventDispatcher = eventDispatcher;
+  }
+  eventDispatcher;
+  static {
+    __name(this, "FinalizeUploadSubscriber");
+  }
+  getSubscribedEvents() {
+    return {
+      [import_events.HttpFileUploaderEvents.FINALIZE_UPLOAD]: { listener: "onFinalizeUpload", priority: 100 }
+    };
+  }
+  async onFinalizeUpload(event) {
+    event.stopPropagation();
+    try {
+      const responseFinalizeUpload = await (0, import_core.safeFetch)({
+        url: event.endPoint,
+        methodSend: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...event.headers
+        },
+        data: { mediaId: event.mediaId, mediaHash: event.mediaHash }
+      });
+      event.setResponse(responseFinalizeUpload);
+    } catch (error) {
+      if (error instanceof import_core.HttpFetchError) {
+        this.eventDispatcher.dispatch(
+          new import_events.FinalizeUploadFailureEvent(error),
+          import_events.HttpFileUploaderEvents.FINALIZE_UPLOAD_FAILURE
+        );
+        return;
+      }
+      throw error;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FinalizeUploadSubscriber,
+  InitializeUploadSubscriber
+});
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/subscribers/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    EventSubscriberInterface,\n    EventDispatcherInterface\n} from \"@wlindabla/event_dispatcher\";\n\nimport {\n    HttpFileUploaderEvents,\n    InitializingUploadEvent,\n    InitializeUploadStartedEvent,\n    InitializeUploadSuccessEvent,\n    InitializeUploadFailureEvent,\n    FinalizeUploadEvent,\n    FinalizeUploadFailureEvent\n} from \"../events\";\n\nimport {\n    HttpFetchError,\n    safeFetch\n} from \"@wlindabla/http_client/core\";\n\nimport { InitializeUploadResponse } from \"../types\";\n\nimport { InitializeUploadFailureException } from \"../exceptions\";\n\n\n//src/subsciber/index.ts\n\nexport class InitializeUploadSubscriber implements EventSubscriberInterface {\n    constructor(private readonly eventDispatcher: EventDispatcherInterface) {\n        \n    }\n\n    public  getSubscribedEvents(): Record<string, string | { listener: string; priority?: number | undefined; }> {\n        return {\n            [HttpFileUploaderEvents.INITIALIZE_UPLOAD]: { listener: \"onInitializeUpload\", priority: 100}\n        }\n    }\n\n    /**\n    * Initializes upload session with the server.\n    * \n    * @param fileHash - SHA-256 hash of the file (first 1MB)\n    * @returns Session ID from server, or null if initialization failed\n    * @throws {FileUploadInitializationError} If server returns error or network fails\n    */\n    public async onInitializeUpload(event:InitializingUploadEvent):Promise<void>{\n        event.stopPropagation();\n        const initialzeUploadRequestOptions = event.initUploadOptions;\n\n        this.eventDispatcher.dispatch(\n            new InitializeUploadStartedEvent(\n               initialzeUploadRequestOptions.fileName,\n                initialzeUploadRequestOptions.fileSize,\n                initialzeUploadRequestOptions.fileHash\n            ),\n            HttpFileUploaderEvents.INITIALIZE_UPLOAD_STARTED\n        );\n            \n        try {\n            const response = await safeFetch({\n                url:initialzeUploadRequestOptions.endpointInit,\n                methodSend: 'POST',\n                headers: {\n                    'Content-Type': 'application/json',\n                    ...initialzeUploadRequestOptions.headers\n                },\n                data: {\n                    fileName:initialzeUploadRequestOptions.fileName,\n                    fileSize:initialzeUploadRequestOptions.fileSize,\n                    fileHash:initialzeUploadRequestOptions.fileHash,\n                    fileType: initialzeUploadRequestOptions.fileType,\n                    metadata: initialzeUploadRequestOptions.metadata,\n                },\n                responseType: \"json\",\n                retryCount: 3,\n                retryOnStatusCode: true,\n                timeout: 45000\n            });\n\n            const status = response.status;\n           \n            // Handle error responses (4xx, 5xx)\n            if (response.failed) {\n                console.error(`Initialize upload failed (HTTP ${status}):`, response);\n\n                const errorUploadFailure =new InitializeUploadFailureException(\n                    response,\n                    `Server returned error: HTTP ${response.status}`\n                );\n\n                this.eventDispatcher.dispatch(\n                    new InitializeUploadFailureEvent(\n                        errorUploadFailure,\n                        status,\n                        response.data),\n                    HttpFileUploaderEvents.INITIALIZE_UPLOAD_FAILURE\n\n                );\n               \n                throw errorUploadFailure;\n            }\n\n            const responseData = response.data as InitializeUploadResponse;\n\n            // Validate server response struct\n            if (!responseData || typeof responseData !== 'object') {\n                const validationError = 'Invalid server response: expected object, got ' + typeof responseData\n                console.error('Invalid response structure:', responseData);\n\n                const err=new InitializeUploadFailureException(\n                    responseData,\n                    validationError\n                );\n                throw err;\n            }\n            // Extract session ID\n            let sessionId =\n                responseData.mediaId ||\n                responseData.mediaIdFromServer ||\n                responseData.sessionId ||\n                responseData.uploadId;\n\n            if (!sessionId) {\n                const missingKeyError = 'Server response missing required field: \"mediaId\",\"mediaIdFromServer\", \"sessionId\", or \"uploadId\"';\n\n                console.error('Missing session ID in response:', responseData);\n                const err=new InitializeUploadFailureException(\n                    responseData,\n                    missingKeyError\n                );\n                throw err;\n            }\n\n            if (typeof sessionId === \"number\") { sessionId = sessionId.toString(); }\n\n            event.setMediaId(sessionId);\n\n            this.eventDispatcher.dispatch(\n                new InitializeUploadSuccessEvent(\n                    status,\n                    sessionId,\n                    responseData\n                ),\n                HttpFileUploaderEvents.INITIALIZE_UPLOAD_SUCCESS\n            );\n\n        } catch (error) {\n            if (error instanceof HttpFetchError) {\n                this.eventDispatcher.dispatch(\n                    new InitializeUploadFailureEvent(\n                        error instanceof Error ? error : new Error(String(error)),\n                    ),\n                    HttpFileUploaderEvents.INITIALIZE_UPLOAD_FAILURE\n                );\n                return;\n            }\n            console.error('Initialize upload exception:', error);\n\n            throw error;\n        }\n    }\n}\n\nexport class FinalizeUploadSubscriber implements EventSubscriberInterface{\n\n    constructor(private readonly eventDispatcher: EventDispatcherInterface) {\n\n    }\n\n    public getSubscribedEvents(): Record<string, string | { listener: string; priority?: number | undefined; }> {\n        return {\n            [HttpFileUploaderEvents.FINALIZE_UPLOAD]: { listener: \"onFinalizeUpload\", priority: 100 }\n        }\n    }\n\n    public async onFinalizeUpload(event: FinalizeUploadEvent): Promise<void>{\n        event.stopPropagation();\n        try {\n            const responseFinalizeUpload = await safeFetch({\n                url: event.endPoint,\n                methodSend: 'POST',\n                headers: {\n                    'Content-Type': 'application/json',\n                    ...event.headers\n                },\n                data: { mediaId: event.mediaId, mediaHash: event.mediaHash }\n            });\n\n            event.setResponse(responseFinalizeUpload)\n        } catch (error) {\n            if (error instanceof HttpFetchError) {\n                this.eventDispatcher.dispatch(\n                    new FinalizeUploadFailureEvent(error),\n                    HttpFileUploaderEvents.FINALIZE_UPLOAD_FAILURE\n                );\n                return;\n            }\n\n            throw error;\n        }\n    }\n}"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,oBAQO;AAEP,kBAGO;AAIP,wBAAiD;AAK1C,MAAM,2BAA+D;AAAA,EACxE,YAA6B,iBAA2C;AAA3C;AAAA,EAE7B;AAAA,EAF6B;AAAA,EAvCjC,OAsC4E;AAAA;AAAA;AAAA,EAKhE,sBAAqG;AACzG,WAAO;AAAA,MACH,CAAC,qCAAuB,iBAAiB,GAAG,EAAE,UAAU,sBAAsB,UAAU,IAAG;AAAA,IAC/F;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAa,mBAAmB,OAA4C;AACxE,UAAM,gBAAgB;AACtB,UAAM,gCAAgC,MAAM;AAE5C,SAAK,gBAAgB;AAAA,MACjB,IAAI;AAAA,QACD,8BAA8B;AAAA,QAC7B,8BAA8B;AAAA,QAC9B,8BAA8B;AAAA,MAClC;AAAA,MACA,qCAAuB;AAAA,IAC3B;AAEA,QAAI;AACA,YAAM,WAAW,UAAM,uBAAU;AAAA,QAC7B,KAAI,8BAA8B;AAAA,QAClC,YAAY;AAAA,QACZ,SAAS;AAAA,UACL,gBAAgB;AAAA,UAChB,GAAG,8BAA8B;AAAA,QACrC;AAAA,QACA,MAAM;AAAA,UACF,UAAS,8BAA8B;AAAA,UACvC,UAAS,8BAA8B;AAAA,UACvC,UAAS,8BAA8B;AAAA,UACvC,UAAU,8BAA8B;AAAA,UACxC,UAAU,8BAA8B;AAAA,QAC5C;AAAA,QACA,cAAc;AAAA,QACd,YAAY;AAAA,QACZ,mBAAmB;AAAA,QACnB,SAAS;AAAA,MACb,CAAC;AAED,YAAM,SAAS,SAAS;AAGxB,UAAI,SAAS,QAAQ;AACjB,gBAAQ,MAAM,kCAAkC,MAAM,MAAM,QAAQ;AAEpE,cAAM,qBAAoB,IAAI;AAAA,UAC1B;AAAA,UACA,+BAA+B,SAAS,MAAM;AAAA,QAClD;AAEA,aAAK,gBAAgB;AAAA,UACjB,IAAI;AAAA,YACA;AAAA,YACA;AAAA,YACA,SAAS;AAAA,UAAI;AAAA,UACjB,qCAAuB;AAAA,QAE3B;AAEA,cAAM;AAAA,MACV;AAEA,YAAM,eAAe,SAAS;AAG9B,UAAI,CAAC,gBAAgB,OAAO,iBAAiB,UAAU;AACnD,cAAM,kBAAkB,mDAAmD,OAAO;AAClF,gBAAQ,MAAM,+BAA+B,YAAY;AAEzD,cAAM,MAAI,IAAI;AAAA,UACV;AAAA,UACA;AAAA,QACJ;AACA,cAAM;AAAA,MACV;AAEA,UAAI,YACA,aAAa,WACb,aAAa,qBACb,aAAa,aACb,aAAa;AAEjB,UAAI,CAAC,WAAW;AACZ,cAAM,kBAAkB;AAExB,gBAAQ,MAAM,mCAAmC,YAAY;AAC7D,cAAM,MAAI,IAAI;AAAA,UACV;AAAA,UACA;AAAA,QACJ;AACA,cAAM;AAAA,MACV;AAEA,UAAI,OAAO,cAAc,UAAU;AAAE,oBAAY,UAAU,SAAS;AAAA,MAAG;AAEvE,YAAM,WAAW,SAAS;AAE1B,WAAK,gBAAgB;AAAA,QACjB,IAAI;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACJ;AAAA,QACA,qCAAuB;AAAA,MAC3B;AAAA,IAEJ,SAAS,OAAO;AACZ,UAAI,iBAAiB,4BAAgB;AACjC,aAAK,gBAAgB;AAAA,UACjB,IAAI;AAAA,YACA,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;AAAA,UAC5D;AAAA,UACA,qCAAuB;AAAA,QAC3B;AACA;AAAA,MACJ;AACA,cAAQ,MAAM,gCAAgC,KAAK;AAEnD,YAAM;AAAA,IACV;AAAA,EACJ;AACJ;AAEO,MAAM,yBAA4D;AAAA,EAErE,YAA6B,iBAA2C;AAA3C;AAAA,EAE7B;AAAA,EAF6B;AAAA,EAhLjC,OA8KyE;AAAA;AAAA;AAAA,EAM9D,sBAAqG;AACxG,WAAO;AAAA,MACH,CAAC,qCAAuB,eAAe,GAAG,EAAE,UAAU,oBAAoB,UAAU,IAAI;AAAA,IAC5F;AAAA,EACJ;AAAA,EAEA,MAAa,iBAAiB,OAA0C;AACpE,UAAM,gBAAgB;AACtB,QAAI;AACA,YAAM,yBAAyB,UAAM,uBAAU;AAAA,QAC3C,KAAK,MAAM;AAAA,QACX,YAAY;AAAA,QACZ,SAAS;AAAA,UACL,gBAAgB;AAAA,UAChB,GAAG,MAAM;AAAA,QACb;AAAA,QACA,MAAM,EAAE,SAAS,MAAM,SAAS,WAAW,MAAM,UAAU;AAAA,MAC/D,CAAC;AAED,YAAM,YAAY,sBAAsB;AAAA,IAC5C,SAAS,OAAO;AACZ,UAAI,iBAAiB,4BAAgB;AACjC,aAAK,gBAAgB;AAAA,UACjB,IAAI,yCAA2B,KAAK;AAAA,UACpC,qCAAuB;AAAA,QAC3B;AACA;AAAA,MACJ;AAEA,YAAM;AAAA,IACV;AAAA,EACJ;AACJ;","names":[]}

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

@@ -0,0 +1,110 @@
+import { FetchResponseInterface } from '@wlindabla/http_client';
+
+interface UploadOptions {
+    autoSave?: boolean;
+    chunkSize?: number;
+    speedMbps?: number;
+    config?: ChunkSizeConfig;
+    headers?: HeadersInit;
+    chunkOtherData?: Record<string, any>;
+    metadata?: Record<string, any>;
+    maxRetries?: number;
+    timeout?: number;
+    initTimeout?: number;
+    headerInitialzingUpload?: HeadersInit;
+    headerFinalezingUpload?: HeadersInit;
+    concurrency?: number;
+}
+interface InitializeUploadOptions {
+    metadata?: Record<string, any>;
+    fileHash: string;
+    fileName: string;
+    fileSize: number;
+    fileType: string;
+    endpointInit: string | URL;
+    headers?: HeadersInit;
+}
+interface UploadEndpoints {
+    init: string | URL;
+    upload: string | URL;
+    finalize: string | URL;
+}
+interface ChunkSizeConfig {
+    defaultChunkSizeMB: number;
+    slowSpeedThresholdMbps: number;
+    slowSpeedChunkSizeMB: number;
+    fileSizeThresholds: Array<{
+        maxSizeMB: number;
+        chunkSizeMB: number;
+    }>;
+}
+type UploadStatus = 'pending' | 'uploading' | 'success' | 'error';
+interface ChunkInfo {
+    index: number;
+    start: number;
+    end: number;
+    size: number;
+    attempt: number;
+    status: UploadStatus;
+}
+declare enum UploadState {
+    IDLE = "idle",
+    INITIALIZING = "initializing",
+    UPLOADING = "uploading",
+    PAUSED = "paused",
+    CANCELLED = "cancelled",
+    FINALIZING = "finalizing",
+    COMPLETED = "completed",
+    FAILED = "failed"
+}
+interface UploadResult {
+    success: boolean;
+    fileId?: string;
+    totalChunks: number;
+    totalBytes: number;
+    duration: number;
+    averageSpeed: number;
+    finalizeUploadResponse?: FetchResponseInterface | null;
+    statusResponse?: number;
+}
+interface ResumeData {
+    fileId: string;
+    fileName: string;
+    fileSize: number;
+    uploadedChunks: number;
+    lastChunkIndex: number;
+    lastBytePosition: number;
+    chunkSize: number;
+    concurrency: number;
+}
+declare const DEFAULT_CONFIG: Readonly<ChunkSizeConfig>;
+interface UploadProgress {
+    uploadedChunks: number;
+    totalChunks: number;
+    uploadedBytes: number;
+    totalBytes: number;
+    percentage: number;
+    currentChunk: number;
+    speed?: number;
+    estimatedTimeRemaining?: number | null;
+    elapsed: number;
+}
+interface ChunkError {
+    chunk: ChunkInfo;
+    error: Error;
+    attempt: number;
+    willRetry: boolean;
+}
+/**
+ * Expected response structure from initialize endpoint
+ */
+interface InitializeUploadResponse {
+    mediaIdFromServer?: string | number;
+    sessionId?: string | number;
+    uploadId?: string | number;
+    mediaId?: string | number;
+    message?: string | number;
+    [key: string]: any;
+}
+
+export { type ChunkError, type ChunkInfo, type ChunkSizeConfig, DEFAULT_CONFIG, type InitializeUploadOptions, type InitializeUploadResponse, type ResumeData, type UploadEndpoints, type UploadOptions, type UploadProgress, type UploadResult, UploadState, type UploadStatus };

package/dist/cjs/types/index.js

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+__export(types_exports, {
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  UploadState: () => UploadState
+});
+module.exports = __toCommonJS(types_exports);
+var UploadState = /* @__PURE__ */ ((UploadState2) => {
+  UploadState2["IDLE"] = "idle";
+  UploadState2["INITIALIZING"] = "initializing";
+  UploadState2["UPLOADING"] = "uploading";
+  UploadState2["PAUSED"] = "paused";
+  UploadState2["CANCELLED"] = "cancelled";
+  UploadState2["FINALIZING"] = "finalizing";
+  UploadState2["COMPLETED"] = "completed";
+  UploadState2["FAILED"] = "failed";
+  return UploadState2;
+})(UploadState || {});
+const DEFAULT_CONFIG = Object.freeze({
+  defaultChunkSizeMB: 50,
+  slowSpeedThresholdMbps: 5,
+  slowSpeedChunkSizeMB: 2,
+  fileSizeThresholds: [
+    { maxSizeMB: 200, chunkSizeMB: 50 },
+    { maxSizeMB: 400, chunkSizeMB: 100 },
+    { maxSizeMB: 800, chunkSizeMB: 300 },
+    { maxSizeMB: 1e3, chunkSizeMB: 500 },
+    { maxSizeMB: Infinity, chunkSizeMB: 700 }
+  ]
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_CONFIG,
+  UploadState
+});
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/types/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 { FetchResponseInterface } from \"@wlindabla/http_client\";\n\nexport interface UploadOptions {\n    autoSave?: boolean,\n    chunkSize?: number;\n    speedMbps?: number;\n    config?: ChunkSizeConfig;\n    headers?: HeadersInit;\n    chunkOtherData?: Record<string, any>;\n    metadata?: Record<string, any>;\n    maxRetries?: number;\n    timeout?: number;\n    initTimeout?: number;\n    headerInitialzingUpload?: HeadersInit;\n    headerFinalezingUpload?: HeadersInit;\n    concurrency?: number; // Default: 3\n}\n\nexport interface InitializeUploadOptions{\n    metadata?: Record<string, any>;\n    fileHash: string;\n    fileName: string;\n    fileSize: number;\n    fileType: string;\n    endpointInit: string | URL;\n    headers?: HeadersInit;\n}\n\nexport interface UploadEndpoints{\n    init: string | URL;\n    upload: string | URL;\n    finalize: string | URL;\n}\n\nexport interface ChunkSizeConfig {\n    defaultChunkSizeMB: number;\n    slowSpeedThresholdMbps: number;\n    slowSpeedChunkSizeMB: number;\n    fileSizeThresholds: Array<{\n        maxSizeMB: number;\n        chunkSizeMB: number;\n    }>;\n}\n\nexport type UploadStatus = 'pending' | 'uploading' | 'success' | 'error';\n\nexport interface ChunkInfo {\n    index: number;\n    start: number;\n    end: number;\n    size: number;\n    attempt: number;\n    status: UploadStatus;\n}\n\nexport enum UploadState {\n    IDLE = 'idle',\n    INITIALIZING = 'initializing',\n    UPLOADING = 'uploading',\n    PAUSED = 'paused',\n    CANCELLED = 'cancelled',\n    FINALIZING = 'finalizing',\n    COMPLETED = 'completed',\n    FAILED = 'failed'\n}\n\nexport interface UploadResult {\n    success: boolean;\n    fileId?: string;\n    totalChunks: number;\n    totalBytes: number;\n    duration: number;\n    averageSpeed: number;\n    finalizeUploadResponse?: FetchResponseInterface | null;\n    statusResponse?: number;\n}\n\nexport interface ResumeData {\n    fileId: string;\n    fileName: string;\n    fileSize: number;\n    uploadedChunks: number;\n    lastChunkIndex: number;\n    lastBytePosition: number;\n    chunkSize: number;\n    concurrency: number;\n}\n\nexport const DEFAULT_CONFIG: Readonly<ChunkSizeConfig> = Object.freeze({\n    defaultChunkSizeMB: 50,\n    slowSpeedThresholdMbps: 5,\n    slowSpeedChunkSizeMB: 2,\n    fileSizeThresholds: [\n        { maxSizeMB: 200, chunkSizeMB: 50 },\n        { maxSizeMB: 400, chunkSizeMB: 100 },\n        { maxSizeMB: 800, chunkSizeMB: 300 },\n        { maxSizeMB: 1000, chunkSizeMB: 500 },\n        { maxSizeMB: Infinity, chunkSizeMB: 700 }\n    ]\n});\n\nexport interface UploadProgress {\n    uploadedChunks: number;\n    totalChunks: number;\n    uploadedBytes: number;\n    totalBytes: number;\n    percentage: number;\n    currentChunk: number;\n    speed?: number; // bytes per second\n    estimatedTimeRemaining?: number | null; // seconds\n    elapsed: number;// secondes écoulées\n}\nexport interface ChunkError {\n    chunk: ChunkInfo;\n    error: Error;\n    attempt: number;\n    willRetry: boolean;\n}\n\n/**\n * Expected response structure from initialize endpoint\n */\nexport interface InitializeUploadResponse {\n    mediaIdFromServer?: string | number;\n    sessionId?: string | number;\n    uploadId?: string | number;\n    mediaId?: string | number;\n    message?: string | number;\n    [key: string]: any; // Allow extra fields\n}"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkEO,IAAK,cAAL,kBAAKA,iBAAL;AACH,EAAAA,aAAA,UAAO;AACP,EAAAA,aAAA,kBAAe;AACf,EAAAA,aAAA,eAAY;AACZ,EAAAA,aAAA,YAAS;AACT,EAAAA,aAAA,eAAY;AACZ,EAAAA,aAAA,gBAAa;AACb,EAAAA,aAAA,eAAY;AACZ,EAAAA,aAAA,YAAS;AARD,SAAAA;AAAA,GAAA;AAiCL,MAAM,iBAA4C,OAAO,OAAO;AAAA,EACnE,oBAAoB;AAAA,EACpB,wBAAwB;AAAA,EACxB,sBAAsB;AAAA,EACtB,oBAAoB;AAAA,IAChB,EAAE,WAAW,KAAK,aAAa,GAAG;AAAA,IAClC,EAAE,WAAW,KAAK,aAAa,IAAI;AAAA,IACnC,EAAE,WAAW,KAAK,aAAa,IAAI;AAAA,IACnC,EAAE,WAAW,KAAM,aAAa,IAAI;AAAA,IACpC,EAAE,WAAW,UAAU,aAAa,IAAI;AAAA,EAC5C;AACJ,CAAC;","names":["UploadState"]}

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

@@ -0,0 +1,72 @@
+import { ChunkSizeConfig } from '../types/index.js';
+import '@wlindabla/http_client';
+
+declare class FileUtils {
+    static readonly MB: number;
+    static readonly GB: number;
+    static bytesToMB(bytes: number): number;
+    static bytesToGB(bytes: number): number;
+    static formatBytes(bytes: number): string;
+    static formatDuration(seconds: number): string;
+    static calculateChunkSize(fileSize: number, speedMbps?: number, config?: ChunkSizeConfig): number;
+    static generateFileHash(file: File | Blob): Promise<string>;
+}
+declare function updateProgressBarHTMLNotified(progress: number, media_id: number, filename: string, providerName?: string): string;
+/**
+ * Options for creating chunk FormData
+ */
+interface ChunkFormDataOptions {
+    chunkIndex: number;
+    totalChunks: number;
+    mediaId: string;
+    fileName: string;
+    fileSize: number;
+    fileHash: string;
+    metadata?: Record<string, string | Blob>;
+}
+/**
+ * Creates FormData for uploading a single file chunk.
+ *
+ * @param chunk - The chunk blob to upload
+ * @param options - Chunk upload options
+ * @returns FormData ready to be sent to the server
+ *
+ * @example
+ * ```typescript
+    * const formData = createChunkFormData(blob, {
+        *   chunkIndex: 5,
+        *   totalChunks: 10,
+        *   mediaId: 'abc123',
+        *   fileName: 'video.mp4',
+        *   fileSize: 104857600,
+        *   fileHash: 'sha256...'
+ * });
+ * ```
+ */
+declare function createChunkFormData(chunk: Blob, options: ChunkFormDataOptions): FormData;
+/**
+ * Builder pattern for creating chunk FormData with fluent API.
+ */
+declare class ChunkFormDataBuilder {
+    private formData;
+    constructor(chunk: Blob);
+    withChunkInfo(chunkIndex: number, totalChunks: number): this;
+    withFileInfo(fileName: string, fileSize: number, fileHash: string): this;
+    withSessionId(sessionId: string): this;
+    withMetadata(metadata: Record<string, string | Blob>): this;
+    build(): FormData;
+}
+interface RetryStrategyInterface {
+    shouldRetry(attempt: number, maxRetries: number, error: Error): boolean;
+    getDelay(attempt: number): number;
+}
+declare class ExponentialBackoffStrategy implements RetryStrategyInterface {
+    shouldRetry(attempt: number, maxRetries: number): boolean;
+    getDelay(attempt: number): number;
+}
+declare class LinearBackoffStrategy implements RetryStrategyInterface {
+    shouldRetry(attempt: number, maxRetries: number): boolean;
+    getDelay(attempt: number): number;
+}
+
+export { ChunkFormDataBuilder, type ChunkFormDataOptions, ExponentialBackoffStrategy, FileUtils, LinearBackoffStrategy, createChunkFormData, updateProgressBarHTMLNotified };

package/dist/cjs/utils/index.js

@@ -0,0 +1,208 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  ChunkFormDataBuilder: () => ChunkFormDataBuilder,
+  ExponentialBackoffStrategy: () => ExponentialBackoffStrategy,
+  FileUtils: () => FileUtils,
+  LinearBackoffStrategy: () => LinearBackoffStrategy,
+  createChunkFormData: () => createChunkFormData,
+  updateProgressBarHTMLNotified: () => updateProgressBarHTMLNotified
+});
+module.exports = __toCommonJS(utils_exports);
+var import_types = require("../types");
+class FileUtils {
+  static {
+    __name(this, "FileUtils");
+  }
+  static MB = 1024 * 1024;
+  static GB = 1024 * 1024 * 1024;
+  static bytesToMB(bytes) {
+    return parseFloat((bytes / this.MB).toFixed(2));
+  }
+  static bytesToGB(bytes) {
+    return parseFloat((bytes / this.GB).toFixed(2));
+  }
+  static formatBytes(bytes) {
+    if (bytes === 0) return "0 Bytes";
+    const k = 1024;
+    const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+  }
+  static formatDuration(seconds) {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor(seconds % 3600 / 60);
+    const secs = Math.floor(seconds % 60);
+    if (hours > 0) return `${hours}h ${minutes}m ${secs}s`;
+    if (minutes > 0) return `${minutes}m ${secs}s`;
+    return `${secs}s`;
+  }
+  static calculateChunkSize(fileSize, speedMbps, config = import_types.DEFAULT_CONFIG) {
+    const fileSizeMB = fileSize / this.MB;
+    if (speedMbps && speedMbps < config.slowSpeedThresholdMbps) {
+      return Math.min(
+        config.defaultChunkSizeMB * this.MB,
+        config.slowSpeedChunkSizeMB * this.MB
+      );
+    }
+    for (const threshold of config.fileSizeThresholds) {
+      if (fileSizeMB <= threshold.maxSizeMB) {
+        return threshold.chunkSizeMB * this.MB;
+      }
+    }
+    return config.defaultChunkSizeMB * this.MB;
+  }
+  static generateFileHash(file) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = async (e) => {
+        try {
+          const buffer = e.target?.result;
+          const hashBuffer = await crypto.subtle.digest("SHA-256", buffer.slice(0, 1024 * 1024));
+          const hashArray = Array.from(new Uint8Array(hashBuffer));
+          const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+          resolve(hashHex);
+        } catch (error) {
+          reject(error);
+        }
+      };
+      reader.onerror = reject;
+      reader.readAsArrayBuffer(file.slice(0, 1024 * 1024));
+    });
+  }
+}
+function updateProgressBarHTMLNotified(progress, media_id, filename, providerName = "LocalVideo") {
+  const progressBarId = `progress-bar-item_${providerName}_${media_id}`;
+  const progressBarContainer = document.querySelector(`#${progressBarId}`);
+  const progressBarInner = progressBarContainer?.querySelector(".progress-bar");
+  if (progressBarInner) {
+    const roundedProgress = Math.round(progress);
+    progressBarInner.style.width = `${progress}%`;
+    progressBarInner.setAttribute("aria-valuenow", progress.toString());
+    progressBarInner.innerText = `${roundedProgress}%`;
+    return progressBarContainer.innerHTML;
+  } else {
+    return `
+            <div id="${progressBarId}" class="mb-2" style="width:100%;">
+                <small class="control-label text-dark fw-bolder filename-label w-100 d-block text-truncate" title="${filename}">
+                    ${filename}
+                </small>
+                <div class="progress">
+                    <div class="progress-bar bg-success progress-bar-striped progress-bar-animated"
+                         role="progressbar"
+                         style="width: ${progress}%;"
+                         aria-valuenow="${progress}"
+                         aria-valuemin="0"
+                         aria-valuemax="100">${Math.round(progress)}%</div>
+                </div>
+            </div>`;
+  }
+}
+__name(updateProgressBarHTMLNotified, "updateProgressBarHTMLNotified");
+function createChunkFormData(chunk, options) {
+  const formData = new FormData();
+  formData.append("chunk", chunk);
+  formData.append("chunkIndex", options.chunkIndex.toString());
+  formData.append("chunkSize", chunk.size.toString());
+  formData.append("totalChunks", options.totalChunks.toString());
+  formData.append("fileName", options.fileName);
+  formData.append("fileSize", options.fileSize.toString());
+  formData.append("fileHash", options.fileHash);
+  formData.append("mediaId", options.mediaId);
+  if (options.metadata) {
+    for (const [key, value] of Object.entries(options.metadata)) {
+      if (typeof value === "string" || value instanceof Blob) {
+        formData.append(key, value);
+      }
+    }
+  }
+  return formData;
+}
+__name(createChunkFormData, "createChunkFormData");
+class ChunkFormDataBuilder {
+  static {
+    __name(this, "ChunkFormDataBuilder");
+  }
+  formData;
+  constructor(chunk) {
+    this.formData = new FormData();
+    this.formData.append("chunk", chunk);
+    this.formData.append("chunkSize", chunk.size.toString());
+  }
+  withChunkInfo(chunkIndex, totalChunks) {
+    this.formData.append("chunkIndex", chunkIndex.toString());
+    this.formData.append("totalChunks", totalChunks.toString());
+    return this;
+  }
+  withFileInfo(fileName, fileSize, fileHash) {
+    this.formData.append("fileName", fileName);
+    this.formData.append("fileSize", fileSize.toString());
+    this.formData.append("fileHash", fileHash);
+    return this;
+  }
+  withSessionId(sessionId) {
+    this.formData.append("sessionId", sessionId);
+    return this;
+  }
+  withMetadata(metadata) {
+    for (const [key, value] of Object.entries(metadata)) {
+      if (typeof value === "string" || value instanceof Blob) {
+        this.formData.append(key, value);
+      }
+    }
+    return this;
+  }
+  build() {
+    return this.formData;
+  }
+}
+class ExponentialBackoffStrategy {
+  static {
+    __name(this, "ExponentialBackoffStrategy");
+  }
+  shouldRetry(attempt, maxRetries) {
+    return attempt < maxRetries;
+  }
+  getDelay(attempt) {
+    return Math.pow(2, attempt) * 1e3;
+  }
+}
+class LinearBackoffStrategy {
+  static {
+    __name(this, "LinearBackoffStrategy");
+  }
+  shouldRetry(attempt, maxRetries) {
+    return attempt < maxRetries;
+  }
+  getDelay(attempt) {
+    return (attempt + 1) * 1e3;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChunkFormDataBuilder,
+  ExponentialBackoffStrategy,
+  FileUtils,
+  LinearBackoffStrategy,
+  createChunkFormData,
+  updateProgressBarHTMLNotified
+});
+//# sourceMappingURL=index.js.map