@wlindabla/file_uploader 1.0.0 → 2.0.1

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

@@ -0,0 +1,45 @@
+import { InitializeUploadOptions, InitializeUploadResponse } from '../../types/index.js';
+import { BaseEvent } from '@wlindabla/event_dispatcher';
+import '@wlindabla/http_client';
+
+/**
+ * Event data for Upload State INITIALIZE
+ */
+declare class InitializingUploadEvent extends BaseEvent {
+    readonly initUploadOptions: InitializeUploadOptions;
+    private _mediaId;
+    constructor(initUploadOptions: InitializeUploadOptions);
+    setMediaId(_mediaUploadId: string): void;
+    get mediaId(): string;
+}
+/**
+ * Event data for INITIALIZE_UPLOAD_STARTED
+ */
+declare class InitializeUploadStartedEvent extends BaseEvent {
+    readonly fileName: string;
+    readonly fileSize: number;
+    readonly fileHash: string;
+    constructor(fileName: string, fileSize: number, fileHash: string);
+}
+/**
+ * Event data for INITIALIZE_UPLOAD_SUCCESS
+ */
+declare class InitializeUploadSuccessEvent extends BaseEvent {
+    readonly status: number;
+    readonly sessionId: string;
+    readonly responseData: InitializeUploadResponse;
+    constructor(status: number, sessionId: string, responseData: InitializeUploadResponse);
+}
+/**
+ * Event data for INITIALIZE_UPLOAD_FAILURE
+ */
+declare class InitializeUploadFailureEvent extends BaseEvent {
+    readonly error: Error;
+    readonly status?: number | undefined;
+    readonly errorData?: any | undefined;
+    readonly responseData?: any | undefined;
+    readonly isNetworkError?: boolean | undefined;
+    constructor(error: Error, status?: number | undefined, errorData?: any | undefined, responseData?: any | undefined, isNetworkError?: boolean | undefined);
+}
+
+export { InitializeUploadFailureEvent, InitializeUploadStartedEvent, InitializeUploadSuccessEvent, InitializingUploadEvent };

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

@@ -0,0 +1,105 @@
+"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 initialize_exports = {};
+__export(initialize_exports, {
+  InitializeUploadFailureEvent: () => InitializeUploadFailureEvent,
+  InitializeUploadStartedEvent: () => InitializeUploadStartedEvent,
+  InitializeUploadSuccessEvent: () => InitializeUploadSuccessEvent,
+  InitializingUploadEvent: () => InitializingUploadEvent
+});
+module.exports = __toCommonJS(initialize_exports);
+var import_event_dispatcher = require("@wlindabla/event_dispatcher");
+class InitializingUploadEvent extends import_event_dispatcher.BaseEvent {
+  constructor(initUploadOptions) {
+    super();
+    this.initUploadOptions = initUploadOptions;
+    this._mediaId = null;
+  }
+  initUploadOptions;
+  static {
+    __name(this, "InitializingUploadEvent");
+  }
+  _mediaId;
+  setMediaId(_mediaUploadId) {
+    this._mediaId = _mediaUploadId;
+  }
+  get mediaId() {
+    if (this._mediaId === null) {
+      throw new Error(
+        "MediaId has not been set. This likely means the InitializeUploadSubscriber failed. Check that INITIALIZE_UPLOAD event was properly handled."
+      );
+    }
+    return this._mediaId;
+  }
+}
+class InitializeUploadStartedEvent extends import_event_dispatcher.BaseEvent {
+  constructor(fileName, fileSize, fileHash) {
+    super();
+    this.fileName = fileName;
+    this.fileSize = fileSize;
+    this.fileHash = fileHash;
+  }
+  fileName;
+  fileSize;
+  fileHash;
+  static {
+    __name(this, "InitializeUploadStartedEvent");
+  }
+}
+class InitializeUploadSuccessEvent extends import_event_dispatcher.BaseEvent {
+  constructor(status, sessionId, responseData) {
+    super();
+    this.status = status;
+    this.sessionId = sessionId;
+    this.responseData = responseData;
+  }
+  status;
+  sessionId;
+  responseData;
+  static {
+    __name(this, "InitializeUploadSuccessEvent");
+  }
+}
+class InitializeUploadFailureEvent extends import_event_dispatcher.BaseEvent {
+  constructor(error, status, errorData, responseData, isNetworkError) {
+    super();
+    this.error = error;
+    this.status = status;
+    this.errorData = errorData;
+    this.responseData = responseData;
+    this.isNetworkError = isNetworkError;
+  }
+  error;
+  status;
+  errorData;
+  responseData;
+  isNetworkError;
+  static {
+    __name(this, "InitializeUploadFailureEvent");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InitializeUploadFailureEvent,
+  InitializeUploadStartedEvent,
+  InitializeUploadSuccessEvent,
+  InitializingUploadEvent
+});
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/events/initialize/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    InitializeUploadOptions,\n    InitializeUploadResponse\n} from \"../../types\";\n\nimport { BaseEvent } from \"@wlindabla/event_dispatcher\";\n\n/**\n * Event data for Upload State INITIALIZE\n */\nexport class InitializingUploadEvent extends BaseEvent{\n    private _mediaId: string | null;\n    constructor(\n        public readonly initUploadOptions: InitializeUploadOptions\n    ) {\n        super();\n        this._mediaId = null;\n    } \n\n    public setMediaId(_mediaUploadId: string) {\n        this._mediaId = _mediaUploadId;\n    }\n\n    public get mediaId(): string {\n        if (this._mediaId === null) {\n            throw new Error(\n                'MediaId has not been set. ' +\n                'This likely means the InitializeUploadSubscriber failed. ' +\n                'Check that INITIALIZE_UPLOAD event was properly handled.'\n            );\n        }\n        return this._mediaId;\n    }\n}\n\n/**\n * Event data for INITIALIZE_UPLOAD_STARTED\n */\nexport class InitializeUploadStartedEvent extends BaseEvent {\n    constructor(\n        public readonly fileName: string,\n        public readonly fileSize: number,\n        public readonly fileHash: string\n    ) { super(); }\n}\n\n/**\n * Event data for INITIALIZE_UPLOAD_SUCCESS\n */\nexport class InitializeUploadSuccessEvent extends BaseEvent{\n    constructor(\n        public readonly status: number,\n        public readonly sessionId: string,\n        public readonly responseData: InitializeUploadResponse\n    ) { super(); }\n}\n\n/**\n * Event data for INITIALIZE_UPLOAD_FAILURE\n */\nexport class InitializeUploadFailureEvent extends BaseEvent {\n    constructor(\n        public readonly error: Error,\n        public readonly status?: number,\n        public readonly errorData?: any,\n        public readonly responseData?: any,\n        public readonly isNetworkError?: boolean\n    ) { super(); }\n}\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,8BAA0B;AAKnB,MAAM,gCAAgC,kCAAS;AAAA,EAElD,YACoB,mBAClB;AACE,UAAM;AAFU;AAGhB,SAAK,WAAW;AAAA,EACpB;AAAA,EAJoB;AAAA,EAxBxB,OAqBsD;AAAA;AAAA;AAAA,EAC1C;AAAA,EAQD,WAAW,gBAAwB;AACtC,SAAK,WAAW;AAAA,EACpB;AAAA,EAEA,IAAW,UAAkB;AACzB,QAAI,KAAK,aAAa,MAAM;AACxB,YAAM,IAAI;AAAA,QACN;AAAA,MAGJ;AAAA,IACJ;AACA,WAAO,KAAK;AAAA,EAChB;AACJ;AAKO,MAAM,qCAAqC,kCAAU;AAAA,EACxD,YACoB,UACA,UACA,UAClB;AAAE,UAAM;AAHU;AACA;AACA;AAAA,EACP;AAAA,EAHO;AAAA,EACA;AAAA,EACA;AAAA,EArDxB,OAiD4D;AAAA;AAAA;AAM5D;AAKO,MAAM,qCAAqC,kCAAS;AAAA,EACvD,YACoB,QACA,WACA,cAClB;AAAE,UAAM;AAHU;AACA;AACA;AAAA,EACP;AAAA,EAHO;AAAA,EACA;AAAA,EACA;AAAA,EAhExB,OA4D2D;AAAA;AAAA;AAM3D;AAKO,MAAM,qCAAqC,kCAAU;AAAA,EACxD,YACoB,OACA,QACA,WACA,cACA,gBAClB;AAAE,UAAM;AALU;AACA;AACA;AACA;AACA;AAAA,EACP;AAAA,EALO;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EA7ExB,OAuE4D;AAAA;AAAA;AAQ5D;","names":[]}

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

@@ -0,0 +1,67 @@
+import { UploadProgress, UploadState } from '../../types/index.js';
+import '@wlindabla/http_client';
+
+/**
+ * Event data for UPLOAD_STATE_CHANGED
+ */
+declare class UploadStateChangedEvent {
+    readonly oldState: UploadState;
+    readonly newState: UploadState;
+    readonly changedAt: number;
+    constructor(oldState: UploadState, newState: UploadState, changedAt?: number);
+}
+/**
+ * Event data for UPLOAD_CANCELLED
+ */
+declare class UploadCancelledEvent {
+    readonly mediaName: string;
+    readonly totalChunks: number;
+    readonly uploadedBytes: number;
+    readonly percentage: number;
+    readonly currentChunkIndex: number;
+    readonly message: string;
+    readonly cancelledAt: number;
+    constructor(mediaName: string, totalChunks: number, uploadedBytes: number, percentage: number, currentChunkIndex: number, message?: string, cancelledAt?: number);
+}
+/**
+ * Event data for UPLOAD_RESUMED
+ */
+declare class UploadResumedEvent {
+    readonly mediaName: string;
+    readonly totalChunks: number;
+    readonly uploadedBytes: number;
+    readonly percentage: number;
+    readonly resumedAt: number;
+    constructor(mediaName: string, totalChunks: number, uploadedBytes: number, percentage: number, resumedAt?: number);
+}
+/**
+ * Event data for UPLOAD_PAUSED
+ */
+declare class UploadPausedEvent {
+    readonly mediaName: string;
+    readonly totalChunks: number;
+    readonly uploadedBytes: number;
+    readonly percentage: number;
+    readonly pausedAt: number;
+    constructor(mediaName: string, totalChunks: number, uploadedBytes: number, percentage: number, pausedAt?: number);
+}
+/**
+ * Event data for MEDIA_CHUNK_UPLOAD_SUCCESS
+ */
+declare class UploadProgressEvent {
+    private readonly uploadProgress;
+    readonly responseData: string | Record<string, string | any> | unknown;
+    readonly httpStatus: number;
+    constructor(uploadProgress: UploadProgress, responseData: string | Record<string, string | any> | unknown, httpStatus: number);
+    get uploadedChunks(): number;
+    get totalChunks(): number;
+    get percentage(): number;
+    get uploadedBytes(): number;
+    get totalBytes(): number;
+    get currentChunk(): number;
+    get speed(): number | undefined;
+    get estimatedTimeRemaining(): number | undefined | null;
+    get elapsed(): number;
+}
+
+export { UploadCancelledEvent, UploadPausedEvent, UploadProgressEvent, UploadResumedEvent, UploadStateChangedEvent };

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

@@ -0,0 +1,145 @@
+"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 state_exports = {};
+__export(state_exports, {
+  UploadCancelledEvent: () => UploadCancelledEvent,
+  UploadPausedEvent: () => UploadPausedEvent,
+  UploadProgressEvent: () => UploadProgressEvent,
+  UploadResumedEvent: () => UploadResumedEvent,
+  UploadStateChangedEvent: () => UploadStateChangedEvent
+});
+module.exports = __toCommonJS(state_exports);
+class UploadStateChangedEvent {
+  constructor(oldState, newState, changedAt = Date.now()) {
+    this.oldState = oldState;
+    this.newState = newState;
+    this.changedAt = changedAt;
+  }
+  oldState;
+  newState;
+  changedAt;
+  static {
+    __name(this, "UploadStateChangedEvent");
+  }
+}
+class UploadCancelledEvent {
+  constructor(mediaName, totalChunks, uploadedBytes, percentage, currentChunkIndex, message = "Upload cancelled by user", cancelledAt = Date.now()) {
+    this.mediaName = mediaName;
+    this.totalChunks = totalChunks;
+    this.uploadedBytes = uploadedBytes;
+    this.percentage = percentage;
+    this.currentChunkIndex = currentChunkIndex;
+    this.message = message;
+    this.cancelledAt = cancelledAt;
+  }
+  mediaName;
+  totalChunks;
+  uploadedBytes;
+  percentage;
+  currentChunkIndex;
+  message;
+  cancelledAt;
+  static {
+    __name(this, "UploadCancelledEvent");
+  }
+}
+class UploadResumedEvent {
+  constructor(mediaName, totalChunks, uploadedBytes, percentage, resumedAt = Date.now()) {
+    this.mediaName = mediaName;
+    this.totalChunks = totalChunks;
+    this.uploadedBytes = uploadedBytes;
+    this.percentage = percentage;
+    this.resumedAt = resumedAt;
+  }
+  mediaName;
+  totalChunks;
+  uploadedBytes;
+  percentage;
+  resumedAt;
+  static {
+    __name(this, "UploadResumedEvent");
+  }
+}
+class UploadPausedEvent {
+  constructor(mediaName, totalChunks, uploadedBytes, percentage, pausedAt = Date.now()) {
+    this.mediaName = mediaName;
+    this.totalChunks = totalChunks;
+    this.uploadedBytes = uploadedBytes;
+    this.percentage = percentage;
+    this.pausedAt = pausedAt;
+  }
+  mediaName;
+  totalChunks;
+  uploadedBytes;
+  percentage;
+  pausedAt;
+  static {
+    __name(this, "UploadPausedEvent");
+  }
+}
+class UploadProgressEvent {
+  constructor(uploadProgress, responseData, httpStatus) {
+    this.uploadProgress = uploadProgress;
+    this.responseData = responseData;
+    this.httpStatus = httpStatus;
+  }
+  uploadProgress;
+  responseData;
+  httpStatus;
+  static {
+    __name(this, "UploadProgressEvent");
+  }
+  get uploadedChunks() {
+    return this.uploadProgress.uploadedChunks;
+  }
+  get totalChunks() {
+    return this.uploadProgress.totalChunks;
+  }
+  get percentage() {
+    return this.uploadProgress.percentage;
+  }
+  get uploadedBytes() {
+    return this.uploadProgress.uploadedBytes;
+  }
+  get totalBytes() {
+    return this.uploadProgress.totalBytes;
+  }
+  get currentChunk() {
+    return this.uploadProgress.currentChunk;
+  }
+  get speed() {
+    return this.uploadProgress.speed;
+  }
+  get estimatedTimeRemaining() {
+    return this.uploadProgress.estimatedTimeRemaining;
+  }
+  get elapsed() {
+    return this.uploadProgress.elapsed;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UploadCancelledEvent,
+  UploadPausedEvent,
+  UploadProgressEvent,
+  UploadResumedEvent,
+  UploadStateChangedEvent
+});
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/events/state/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    UploadState,\n    UploadProgress\n} from \"../../types\";\n\n/**\n * Event data for UPLOAD_STATE_CHANGED\n */\nexport class UploadStateChangedEvent {\n    constructor(\n        public readonly oldState: UploadState,\n        public readonly newState: UploadState,\n        public readonly changedAt: number = Date.now()\n    ) { }\n}\n\n\n/**\n * Event data for UPLOAD_CANCELLED\n */\nexport class UploadCancelledEvent {\n    constructor(\n        public readonly mediaName: string,\n        public readonly totalChunks: number,\n        public readonly uploadedBytes: number,\n        public readonly percentage: number,\n        public readonly currentChunkIndex:number,\n        public readonly message: string =\"Upload cancelled by user\",\n        public readonly cancelledAt: number = Date.now()\n    ) { }\n}\n\n\n/**\n * Event data for UPLOAD_RESUMED\n */\nexport class UploadResumedEvent {\n    constructor(\n        public readonly mediaName: string,\n        public readonly totalChunks: number,\n        public readonly uploadedBytes: number,\n        public readonly percentage: number,\n        public readonly resumedAt: number = Date.now()\n    ) { }\n}\n\n/**\n * Event data for UPLOAD_PAUSED\n */\nexport class UploadPausedEvent {\n    constructor(\n        public readonly mediaName: string,\n        public readonly totalChunks: number,\n        public readonly uploadedBytes: number,\n        public readonly percentage: number,\n        public readonly pausedAt: number = Date.now()\n    ) { }\n}\n\n/**\n * Event data for MEDIA_CHUNK_UPLOAD_SUCCESS\n */\nexport class UploadProgressEvent {\n    constructor(\n        private readonly uploadProgress: UploadProgress,\n        public readonly responseData: string | Record<string, string | any> | unknown,\n        public readonly httpStatus: number\n    ) { }\n\n    public get uploadedChunks(): number { return this.uploadProgress.uploadedChunks; }\n\n    public get totalChunks(): number { return this.uploadProgress.totalChunks; }\n\n    public get percentage(): number { return this.uploadProgress.percentage; }\n\n    public get uploadedBytes(): number { return this.uploadProgress.uploadedBytes; }\n\n    public get totalBytes(): number { return this.uploadProgress.totalBytes; }\n\n    public get currentChunk(): number { return this.uploadProgress.currentChunk; }\n\n    public get speed(): number | undefined { return this.uploadProgress.speed; }\n\n    public get estimatedTimeRemaining(): number | undefined | null { return this.uploadProgress.estimatedTimeRemaining; }\n\n    public get elapsed(): number { return this.uploadProgress.elapsed; }\n}\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmBO,MAAM,wBAAwB;AAAA,EACjC,YACoB,UACA,UACA,YAAoB,KAAK,IAAI,GAC/C;AAHkB;AACA;AACA;AAAA,EAChB;AAAA,EAHgB;AAAA,EACA;AAAA,EACA;AAAA,EAvBxB,OAmBqC;AAAA;AAAA;AAMrC;AAMO,MAAM,qBAAqB;AAAA,EAC9B,YACoB,WACA,aACA,eACA,YACA,mBACA,UAAiB,4BACjB,cAAsB,KAAK,IAAI,GACjD;AAPkB;AACA;AACA;AACA;AACA;AACA;AACA;AAAA,EAChB;AAAA,EAPgB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAvCxB,OA+BkC;AAAA;AAAA;AAUlC;AAMO,MAAM,mBAAmB;AAAA,EAC5B,YACoB,WACA,aACA,eACA,YACA,YAAoB,KAAK,IAAI,GAC/C;AALkB;AACA;AACA;AACA;AACA;AAAA,EAChB;AAAA,EALgB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EArDxB,OA+CgC;AAAA;AAAA;AAQhC;AAKO,MAAM,kBAAkB;AAAA,EAC3B,YACoB,WACA,aACA,eACA,YACA,WAAmB,KAAK,IAAI,GAC9C;AALkB;AACA;AACA;AACA;AACA;AAAA,EAChB;AAAA,EALgB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAlExB,OA4D+B;AAAA;AAAA;AAQ/B;AAKO,MAAM,oBAAoB;AAAA,EAC7B,YACqB,gBACD,cACA,YAClB;AAHmB;AACD;AACA;AAAA,EAChB;AAAA,EAHiB;AAAA,EACD;AAAA,EACA;AAAA,EA7ExB,OAyEiC;AAAA;AAAA;AAAA,EAO7B,IAAW,iBAAyB;AAAE,WAAO,KAAK,eAAe;AAAA,EAAgB;AAAA,EAEjF,IAAW,cAAsB;AAAE,WAAO,KAAK,eAAe;AAAA,EAAa;AAAA,EAE3E,IAAW,aAAqB;AAAE,WAAO,KAAK,eAAe;AAAA,EAAY;AAAA,EAEzE,IAAW,gBAAwB;AAAE,WAAO,KAAK,eAAe;AAAA,EAAe;AAAA,EAE/E,IAAW,aAAqB;AAAE,WAAO,KAAK,eAAe;AAAA,EAAY;AAAA,EAEzE,IAAW,eAAuB;AAAE,WAAO,KAAK,eAAe;AAAA,EAAc;AAAA,EAE7E,IAAW,QAA4B;AAAE,WAAO,KAAK,eAAe;AAAA,EAAO;AAAA,EAE3E,IAAW,yBAAoD;AAAE,WAAO,KAAK,eAAe;AAAA,EAAwB;AAAA,EAEpH,IAAW,UAAkB;AAAE,WAAO,KAAK,eAAe;AAAA,EAAS;AACvE;","names":[]}

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

@@ -0,0 +1,84 @@
+import { ChunkError, ChunkInfo } from '../types/index.js';
+import '@wlindabla/http_client';
+
+declare class InitializeUploadFailureException extends Error {
+    readonly responseData: any;
+    constructor(responseData: any, message: string);
+}
+/**
+ * Exception data for MEDIA_CHUNK_UPLOAD_HTTP_ERROR_RESPONSE
+ */
+declare class ChunkUploadHttpErrorException extends Error {
+    readonly errorPayload: string | Record<string, string | unknown> | unknown;
+    readonly statusResponse: number;
+    constructor(errorPayload: string | Record<string, string | unknown> | unknown, statusResponse: number);
+}
+/**
+ * Custom error thrown during chunked file upload operations.
+ *
+ * This error provides detailed information about which chunk failed,
+ * the underlying error, and whether a retry will be attempted.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await uploadChunk(chunk);
+ * } catch (error) {
+ *   throw new FileUploadChunkError(
+ *     `Failed to upload chunk ${chunkIndex}`,
+ *     chunkError
+ *   );
+ * }
+ *
+ * // Later in error handler
+ * if (error instanceof FileUploadChunkError) {
+ *   console.log(`Chunk ${error.chunkIndex} failed`);
+ *   console.log(`Will retry: ${error.willRetry}`);
+ * }
+ * ```
+ */
+declare class FileUploadChunkError extends Error {
+    /**
+     * The detailed chunk error information
+     */
+    readonly chunkError: ChunkError;
+    /**
+     * Creates a new FileUploadChunkError
+     *
+     * @param message - Human-readable error message
+     * @param chunkError - Detailed information about the chunk failure
+     */
+    constructor(message: string, chunkError: ChunkError);
+    /**
+     * Gets the index of the chunk that failed
+     */
+    get chunkIndex(): number;
+    /**
+     * Gets the attempt number when the chunk failed
+     */
+    get attemptNumber(): number;
+    /**
+     * Indicates whether a retry will be attempted
+     */
+    get willRetry(): boolean;
+    /**
+     * Gets the underlying error that caused the chunk upload to fail
+     */
+    get underlyingError(): Error;
+    /**
+     * Gets the full chunk information
+     */
+    get chunk(): ChunkInfo;
+    /**
+     * Returns a JSON representation of the error
+     */
+    toJSON(): object;
+}
+declare class UploadCancelledException extends Error {
+    readonly chunkIndex: number;
+    readonly totalChunks: number;
+    readonly uploadedBytes: number;
+    constructor(chunkIndex: number, totalChunks: number, uploadedBytes: number, message: string);
+}
+
+export { ChunkUploadHttpErrorException, FileUploadChunkError, InitializeUploadFailureException, UploadCancelledException };

package/dist/{exceptions → cjs/exceptions}/index.js

@@ -1,7 +1,30 @@
-'use strict';
-
+"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 exceptions_exports = {};
+__export(exceptions_exports, {
+  ChunkUploadHttpErrorException: () => ChunkUploadHttpErrorException,
+  FileUploadChunkError: () => FileUploadChunkError,
+  InitializeUploadFailureException: () => InitializeUploadFailureException,
+  UploadCancelledException: () => UploadCancelledException
+});
+module.exports = __toCommonJS(exceptions_exports);
 class InitializeUploadFailureException extends Error {
   constructor(responseData, message) {
     super(message);
@@ -11,6 +34,7 @@ class InitializeUploadFailureException extends Error {
       Error.captureStackTrace(this, InitializeUploadFailureException);
     }
   }
+  responseData;
   static {
     __name(this, "InitializeUploadFailureException");
   }
@@ -25,6 +49,8 @@ class ChunkUploadHttpErrorException extends Error {
       Error.captureStackTrace(this, ChunkUploadHttpErrorException);
     }
   }
+  errorPayload;
+  statusResponse;
   static {
     __name(this, "ChunkUploadHttpErrorException");
   }
@@ -81,16 +107,6 @@ class FileUploadChunkError extends Error {
   get chunk() {
     return this.chunkError.chunk;
   }
-  /**
-   * Returns a detailed string representation of the error
-   */
-  toString() {
-    return `${this.name}: ${this.message}
-  Chunk: ${this.chunkIndex + 1}/${this.chunk.size} bytes
-  Attempt: ${this.attemptNumber}
-  Will Retry: ${this.willRetry}
-  Cause: ${this.underlyingError.message}`;
-  }
   /**
    * Returns a JSON representation of the error
    */
@@ -120,14 +136,18 @@ class UploadCancelledException extends Error {
       Error.captureStackTrace(this, UploadCancelledException);
     }
   }
+  chunkIndex;
+  totalChunks;
+  uploadedBytes;
   static {
     __name(this, "UploadCancelledException");
   }
 }
-
-exports.ChunkUploadHttpErrorException = ChunkUploadHttpErrorException;
-exports.FileUploadChunkError = FileUploadChunkError;
-exports.InitializeUploadFailureException = InitializeUploadFailureException;
-exports.UploadCancelledException = UploadCancelledException;
-//# sourceMappingURL=index.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChunkUploadHttpErrorException,
+  FileUploadChunkError,
+  InitializeUploadFailureException,
+  UploadCancelledException
+});
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/exceptions/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 { ChunkInfo, ChunkError } from \"../types\";\n\nexport class InitializeUploadFailureException extends Error {\n    constructor(public readonly responseData: any, message: string) {\n        super(message);\n        this.name = \"InitializeUploadFailureException\";\n\n        if (Error.captureStackTrace) {\n            Error.captureStackTrace(this, InitializeUploadFailureException);\n        }\n    }\n}\n\n/**\n * Exception data for MEDIA_CHUNK_UPLOAD_HTTP_ERROR_RESPONSE\n */\nexport class ChunkUploadHttpErrorException extends Error {\n    constructor(\n        public readonly errorPayload: string | Record<string, string | unknown> | unknown,\n        public readonly statusResponse: number\n    ) {\n        super();\n\n        this.name = \"ChunkUploadHttpErrorException\";\n\n        if (Error.captureStackTrace) {\n            Error.captureStackTrace(this, ChunkUploadHttpErrorException);\n        }\n    }\n}\n\n/**\n * Custom error thrown during chunked file upload operations.\n * \n * This error provides detailed information about which chunk failed,\n * the underlying error, and whether a retry will be attempted.\n * \n * @example\n * ```typescript\n * try {\n *   await uploadChunk(chunk);\n * } catch (error) {\n *   throw new FileUploadChunkError(\n *     `Failed to upload chunk ${chunkIndex}`,\n *     chunkError\n *   );\n * }\n * \n * // Later in error handler\n * if (error instanceof FileUploadChunkError) {\n *   console.log(`Chunk ${error.chunkIndex} failed`);\n *   console.log(`Will retry: ${error.willRetry}`);\n * }\n * ```\n */\nexport class FileUploadChunkError extends Error {\n\n    /**\n     * The detailed chunk error information\n     */\n    public readonly chunkError: ChunkError;\n\n    /**\n     * Creates a new FileUploadChunkError\n     * \n     * @param message - Human-readable error message\n     * @param chunkError - Detailed information about the chunk failure\n     */\n    constructor(message: string, chunkError: ChunkError) {\n        super(message, { cause: chunkError.error });\n\n        this.name = \"FileUploadChunkError\";\n        this.chunkError = chunkError;\n\n        // Maintain proper stack trace in V8 engines (Chrome, Node.js)\n        if (Error.captureStackTrace) {\n            Error.captureStackTrace(this, FileUploadChunkError);\n        }\n    }\n\n    /**\n     * Gets the index of the chunk that failed\n     */\n    get chunkIndex(): number {\n        return this.chunkError.chunk.index;\n    }\n\n    /**\n     * Gets the attempt number when the chunk failed\n     */\n    get attemptNumber(): number {\n        return this.chunkError.attempt;\n    }\n\n    /**\n     * Indicates whether a retry will be attempted\n     */\n    get willRetry(): boolean {\n        return this.chunkError.willRetry;\n    }\n\n    /**\n     * Gets the underlying error that caused the chunk upload to fail\n     */\n    get underlyingError(): Error {\n        return this.chunkError.error;\n    }\n\n    /**\n     * Gets the full chunk information\n     */\n    get chunk(): ChunkInfo {\n        return this.chunkError.chunk;\n    }\n    \n    /**\n     * Returns a JSON representation of the error\n     */\n    toJSON(): object {\n        return {\n            name: this.name,\n            message: this.message,\n            chunkIndex: this.chunkIndex,\n            attempt: this.attemptNumber,\n            willRetry: this.willRetry,\n            underlyingError: {\n                name: this.underlyingError.name,\n                message: this.underlyingError.message\n            },\n            stack: this.stack\n        };\n    }\n}\n\n\nexport class UploadCancelledException extends Error {\n    constructor(\n        public readonly chunkIndex: number,\n        public readonly totalChunks: number,\n        public readonly uploadedBytes: number,\n        message: string\n    ) {\n        super(message);\n        this.name = \"UploadCancelledException\";\n\n        if (Error.captureStackTrace) {\n            Error.captureStackTrace(this, UploadCancelledException);\n        }\n    }\n}"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAaO,MAAM,yCAAyC,MAAM;AAAA,EACxD,YAA4B,cAAmB,SAAiB;AAC5D,UAAM,OAAO;AADW;AAExB,SAAK,OAAO;AAEZ,QAAI,MAAM,mBAAmB;AACzB,YAAM,kBAAkB,MAAM,gCAAgC;AAAA,IAClE;AAAA,EACJ;AAAA,EAP4B;AAAA,EAdhC,OAa4D;AAAA;AAAA;AAS5D;AAKO,MAAM,sCAAsC,MAAM;AAAA,EACrD,YACoB,cACA,gBAClB;AACE,UAAM;AAHU;AACA;AAIhB,SAAK,OAAO;AAEZ,QAAI,MAAM,mBAAmB;AACzB,YAAM,kBAAkB,MAAM,6BAA6B;AAAA,IAC/D;AAAA,EACJ;AAAA,EAVoB;AAAA,EACA;AAAA,EA9BxB,OA2ByD;AAAA;AAAA;AAazD;AA0BO,MAAM,6BAA6B,MAAM;AAAA,EAlEhD,OAkEgD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAK5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQhB,YAAY,SAAiB,YAAwB;AACjD,UAAM,SAAS,EAAE,OAAO,WAAW,MAAM,CAAC;AAE1C,SAAK,OAAO;AACZ,SAAK,aAAa;AAGlB,QAAI,MAAM,mBAAmB;AACzB,YAAM,kBAAkB,MAAM,oBAAoB;AAAA,IACtD;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,aAAqB;AACrB,WAAO,KAAK,WAAW,MAAM;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,gBAAwB;AACxB,WAAO,KAAK,WAAW;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,YAAqB;AACrB,WAAO,KAAK,WAAW;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,kBAAyB;AACzB,WAAO,KAAK,WAAW;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,QAAmB;AACnB,WAAO,KAAK,WAAW;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA,EAKA,SAAiB;AACb,WAAO;AAAA,MACH,MAAM,KAAK;AAAA,MACX,SAAS,KAAK;AAAA,MACd,YAAY,KAAK;AAAA,MACjB,SAAS,KAAK;AAAA,MACd,WAAW,KAAK;AAAA,MAChB,iBAAiB;AAAA,QACb,MAAM,KAAK,gBAAgB;AAAA,QAC3B,SAAS,KAAK,gBAAgB;AAAA,MAClC;AAAA,MACA,OAAO,KAAK;AAAA,IAChB;AAAA,EACJ;AACJ;AAGO,MAAM,iCAAiC,MAAM;AAAA,EAChD,YACoB,YACA,aACA,eAChB,SACF;AACE,UAAM,OAAO;AALG;AACA;AACA;AAIhB,SAAK,OAAO;AAEZ,QAAI,MAAM,mBAAmB;AACzB,YAAM,kBAAkB,MAAM,wBAAwB;AAAA,IAC1D;AAAA,EACJ;AAAA,EAXoB;AAAA,EACA;AAAA,EACA;AAAA,EAtJxB,OAkJoD;AAAA;AAAA;AAcpD;","names":[]}

package/dist/cjs/index.d.ts

@@ -0,0 +1,14 @@
+export { ChunkError, ChunkInfo, ChunkSizeConfig, DEFAULT_CONFIG, InitializeUploadOptions, InitializeUploadResponse, ResumeData, UploadEndpoints, UploadOptions, UploadProgress, UploadResult, UploadState, UploadStatus } from './types/index.js';
+export { ChunkFormDataBuilder, ChunkFormDataOptions, ExponentialBackoffStrategy, FileUtils, LinearBackoffStrategy, createChunkFormData, updateProgressBarHTMLNotified } from './utils/index.js';
+export { ChunkUploadHttpErrorException, FileUploadChunkError, InitializeUploadFailureException, UploadCancelledException } from './exceptions/index.js';
+export { HttpFileUploaderEvents } from './events/index.js';
+export { FinalizeUploadSubscriber, InitializeUploadSubscriber } from './subscribers/index.js';
+export { DefaultUploadResumeCacheAdapter, UploadCacheError, UploadResumeCacheInterface } from './cache/index.js';
+export { ChunkedFileUploader } from './core/index.js';
+export { ChunkUploadHttpErrorResponseEvent, UploadChunkStartedEvent } from './events/chunk/index.js';
+export { FinalizeUploadEvent, FinalizeUploadFailureEvent, ResumeUploadEvent, UploadMediaCompleteEvent } from './events/complete/index.js';
+export { InitializeUploadFailureEvent, InitializeUploadStartedEvent, InitializeUploadSuccessEvent, InitializingUploadEvent } from './events/initialize/index.js';
+export { UploadCancelledEvent, UploadPausedEvent, UploadProgressEvent, UploadResumedEvent, UploadStateChangedEvent } from './events/state/index.js';
+import '@wlindabla/http_client';
+import '@wlindabla/event_dispatcher';
+import '@wlindabla/http_client/events';

package/dist/cjs/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./utils"), module.exports);
+__reExport(src_exports, require("./exceptions"), module.exports);
+__reExport(src_exports, require("./events"), module.exports);
+__reExport(src_exports, require("./subscribers"), module.exports);
+__reExport(src_exports, require("./cache"), module.exports);
+__reExport(src_exports, require("./core"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./utils"),
+  ...require("./exceptions"),
+  ...require("./events"),
+  ...require("./subscribers"),
+  ...require("./cache"),
+  ...require("./core")
+});
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export type * from \"./types\";\nexport * from \"./utils\";\nexport * from \"./exceptions\";\nexport * from \"./events\";\nexport * from \"./subscribers\";\nexport * from \"./cache\";\nexport * from \"./core\";"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AACA,wBAAc,oBADd;AAEA,wBAAc,yBAFd;AAGA,wBAAc,qBAHd;AAIA,wBAAc,0BAJd;AAKA,wBAAc,oBALd;AAMA,wBAAc,mBANd;","names":[]}

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

@@ -0,0 +1,34 @@
+import { EventSubscriberInterface, EventDispatcherInterface } from '@wlindabla/event_dispatcher';
+import { InitializingUploadEvent } from '../events/initialize/index.js';
+import { FinalizeUploadEvent } from '../events/complete/index.js';
+import '../types/index.js';
+import '@wlindabla/http_client';
+import '@wlindabla/http_client/events';
+
+declare class InitializeUploadSubscriber implements EventSubscriberInterface {
+    private readonly eventDispatcher;
+    constructor(eventDispatcher: EventDispatcherInterface);
+    getSubscribedEvents(): Record<string, string | {
+        listener: string;
+        priority?: number | undefined;
+    }>;
+    /**
+    * 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
+    */
+    onInitializeUpload(event: InitializingUploadEvent): Promise<void>;
+}
+declare class FinalizeUploadSubscriber implements EventSubscriberInterface {
+    private readonly eventDispatcher;
+    constructor(eventDispatcher: EventDispatcherInterface);
+    getSubscribedEvents(): Record<string, string | {
+        listener: string;
+        priority?: number | undefined;
+    }>;
+    onFinalizeUpload(event: FinalizeUploadEvent): Promise<void>;
+}
+
+export { FinalizeUploadSubscriber, InitializeUploadSubscriber };