@wlindabla/file_uploader 1.0.0 → 2.0.0

package/dist/esm/events/index.d.mts

@@ -0,0 +1,94 @@
+export { InitializeUploadFailureEvent, InitializeUploadStartedEvent, InitializeUploadSuccessEvent, InitializingUploadEvent } from './initialize/index.mjs';
+export { UploadCancelledEvent, UploadPausedEvent, UploadProgressEvent, UploadResumedEvent, UploadStateChangedEvent } from './state/index.mjs';
+export { ChunkUploadHttpErrorResponseEvent, UploadChunkStartedEvent } from './chunk/index.mjs';
+export { FinalizeUploadEvent, FinalizeUploadFailureEvent, ResumeUploadEvent, UploadMediaCompleteEvent } from './complete/index.mjs';
+import '../types/index.mjs';
+import '@wlindabla/http_client';
+import '@wlindabla/event_dispatcher';
+
+/**
+ * HttpFileUploaderEvents - Event Constants for File Upload Operations
+ *
+ * This abstract class provides a centralized collection of event name constants
+ * used throughout the file upload lifecycle. It follows the Symfony event
+ * dispatcher pattern, providing a type-safe way to reference events.
+ *
+ * The events are organized into five categories:
+ * - **Initialize Events**: Events related to upload session initialization
+ * - **Chunk Upload Events**: Events fired during individual chunk uploads
+ * - **Upload State Events**: Events tracking upload state changes (pause, resume, cancel)
+ * - **Completion Events**: Events fired when upload completes or fails
+ * - **Metadata Events**: Events related to media metadata operations
+ *
+ * @example
+ * ```typescript
+ * import { HttpFileUploaderEvents } from '@wlindabla/file_uploader';
+ *
+ * // Listen to chunk upload success
+ * dispatcher.addListener(
+ *   HttpFileUploaderEvents.MEDIA_CHUNK_UPLOAD_SUCCESS,
+ *   (event: ChunkUploadSuccessEvent) => {
+ *     console.log('Chunk uploaded:', event.progress);
+ *   }
+ * );
+ *
+ * // Listen to upload state changes
+ * dispatcher.addListener(
+ *   HttpFileUploaderEvents.UPLOAD_STATE_CHANGED,
+ *   (event: UploadStateChangedEvent) => {
+ *     console.log(`State changed: ${event.oldState} → ${event.newState}`);
+ *   }
+ * );
+ * ```
+ *
+ * @author AGBOKOUDJO Franck <internationaleswebservices@gmail.com>
+ * @version 1.0.0
+ * @since 1.0.0
+ *
+ * @see {@link https://github.com/Agbokoudjo/file_uploader | GitHub Repository}
+ * @see {@link EventDispatcherInterface} for event dispatcher usage
+ */
+declare abstract class HttpFileUploaderEvents {
+    static readonly INITIALIZE_UPLOAD = "initializingUpload";
+    /** Dispatched when upload initialization starts */
+    static readonly INITIALIZE_UPLOAD_STARTED = "initializeUploadStarted";
+    /** Dispatched when upload initialization succeeds */
+    static readonly INITIALIZE_UPLOAD_SUCCESS = "initializeUploadSuccess";
+    /** Dispatched when upload initialization fails */
+    static readonly INITIALIZE_UPLOAD_FAILURE = "initializeUploadFailure";
+    /** Dispatched when a chunk upload starts */
+    static readonly MEDIA_CHUNK_UPLOAD_STARTED = "mediaChunkUploadStarted";
+    /** Dispatched when a chunk is uploaded successfully */
+    static readonly MEDIA_CHUNK_UPLOAD_SUCCESS = "mediaChunkUploadSuccess";
+    /** Dispatched when a chunk upload fails */
+    static readonly MEDIA_CHUNK_UPLOAD_FAILED = "mediaChunkUploadFailed";
+    /** Dispatched when the server returns an HTTP error for a chunk */
+    static readonly MEDIA_CHUNK_UPLOAD_HTTP_ERROR_RESPONSE = "mediaChunkUploadHttpErrorResponse";
+    /** Dispatched to provide the status of a chunk */
+    static readonly MEDIA_CHUNK_UPLOAD_STATUS = "mediaChunkUploadStatus";
+    /** Dispatched when maximum retry attempts are exceeded for a chunk */
+    static readonly MEDIA_CHUNK_UPLOAD_MAXRETRY_EXPIRE = "mediaChunkUploadMaxRetryExpire";
+    /** Dispatched when a chunk upload resumes */
+    static readonly MEDIA_CHUNK_UPLOAD_RESUME = "mediaChunkUploadResume";
+    /** Dispatched when the upload is paused */
+    static readonly UPLOAD_PAUSED = "uploadPaused";
+    /** Dispatched when the upload resumes after being paused */
+    static readonly UPLOAD_RESUMED = "uploadResumed";
+    /** Dispatched when the upload is cancelled */
+    static readonly UPLOAD_CANCELLED = "uploadCancelled";
+    /** Dispatched when the upload state changes */
+    static readonly UPLOAD_STATE_CHANGED = "uploadStateChanged";
+    /** Dispatched when the upload completes successfully */
+    static readonly DOWNLOAD_MEDIA_COMPLETE = "downloadMediaComplete";
+    /** Dispatched when the upload fails completely */
+    static readonly DOWNLOAD_MEDIA_FAILURE = "downloadMediaFailure";
+    /** Dispatched when the upload resumes from a saved state */
+    static readonly DOWNLOAD_MEDIA_RESUME = "downloadMediaResume";
+    static readonly FINALIZE_UPLOAD = "finalizeUpload";
+    static readonly FINALIZE_UPLOAD_FAILURE = "finalizeUploadFailure";
+    /** Dispatched when media metadata is saved successfully */
+    static readonly MEDIA_METADATA_SAVE_SUCCESS = "mediaMetadataSaveSuccess";
+    private constructor();
+}
+
+export { HttpFileUploaderEvents };

package/dist/esm/events/index.js

@@ -0,0 +1,8 @@
+export { HttpFileUploaderEvents } from '../chunk-JDL3U4OX.js';
+export { ChunkUploadHttpErrorResponseEvent, UploadChunkStartedEvent } from '../chunk-LD2DWZRJ.js';
+export { FinalizeUploadEvent, FinalizeUploadFailureEvent, ResumeUploadEvent, UploadMediaCompleteEvent } from '../chunk-LTYMA4U4.js';
+export { InitializeUploadFailureEvent, InitializeUploadStartedEvent, InitializeUploadSuccessEvent, InitializingUploadEvent } from '../chunk-DN5B6PRW.js';
+export { UploadCancelledEvent, UploadPausedEvent, UploadProgressEvent, UploadResumedEvent, UploadStateChangedEvent } from '../chunk-6225YMFE.js';
+import '../chunk-7QVYU63E.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/esm/events/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/esm/events/initialize/index.d.mts

@@ -0,0 +1,45 @@
+import { InitializeUploadOptions, InitializeUploadResponse } from '../../types/index.mjs';
+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/esm/events/initialize/index.js

@@ -0,0 +1,4 @@
+export { InitializeUploadFailureEvent, InitializeUploadStartedEvent, InitializeUploadSuccessEvent, InitializingUploadEvent } from '../../chunk-DN5B6PRW.js';
+import '../../chunk-7QVYU63E.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/esm/events/state/index.d.mts

@@ -0,0 +1,67 @@
+import { UploadProgress, UploadState } from '../../types/index.mjs';
+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/esm/events/state/index.js

@@ -0,0 +1,4 @@
+export { UploadCancelledEvent, UploadPausedEvent, UploadProgressEvent, UploadResumedEvent, UploadStateChangedEvent } from '../../chunk-6225YMFE.js';
+import '../../chunk-7QVYU63E.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/esm/exceptions/index.d.mts

@@ -0,0 +1,84 @@
+import { ChunkError, ChunkInfo } from '../types/index.mjs';
+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/esm/exceptions/index.js

@@ -0,0 +1,4 @@
+export { ChunkUploadHttpErrorException, FileUploadChunkError, InitializeUploadFailureException, UploadCancelledException } from '../chunk-NXYS73I4.js';
+import '../chunk-7QVYU63E.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/esm/index.d.mts

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

package/dist/esm/index.js

@@ -0,0 +1,14 @@
+export { FinalizeUploadSubscriber, InitializeUploadSubscriber } from './chunk-332NNKOW.js';
+export { DefaultUploadResumeCacheAdapter, UploadCacheError } from './chunk-PFALORWQ.js';
+export { ChunkedFileUploader } from './chunk-6DIKDA6J.js';
+export { ChunkUploadHttpErrorException, FileUploadChunkError, InitializeUploadFailureException, UploadCancelledException } from './chunk-NXYS73I4.js';
+export { ChunkFormDataBuilder, ExponentialBackoffStrategy, FileUtils, LinearBackoffStrategy, createChunkFormData, updateProgressBarHTMLNotified } from './chunk-MFYC4PBP.js';
+import './chunk-X757PBC5.js';
+export { HttpFileUploaderEvents } from './chunk-JDL3U4OX.js';
+export { ChunkUploadHttpErrorResponseEvent, UploadChunkStartedEvent } from './chunk-LD2DWZRJ.js';
+export { FinalizeUploadEvent, FinalizeUploadFailureEvent, ResumeUploadEvent, UploadMediaCompleteEvent } from './chunk-LTYMA4U4.js';
+export { InitializeUploadFailureEvent, InitializeUploadStartedEvent, InitializeUploadSuccessEvent, InitializingUploadEvent } from './chunk-DN5B6PRW.js';
+export { UploadCancelledEvent, UploadPausedEvent, UploadProgressEvent, UploadResumedEvent, UploadStateChangedEvent } from './chunk-6225YMFE.js';
+import './chunk-7QVYU63E.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/esm/subscribers/index.d.mts

@@ -0,0 +1,33 @@
+import { EventSubscriberInterface, EventDispatcherInterface } from '@wlindabla/event_dispatcher';
+import { InitializingUploadEvent } from '../events/initialize/index.mjs';
+import { FinalizeUploadEvent } from '../events/complete/index.mjs';
+import '../types/index.mjs';
+import '@wlindabla/http_client';
+
+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 };

package/dist/esm/subscribers/index.js

@@ -0,0 +1,10 @@
+export { FinalizeUploadSubscriber, InitializeUploadSubscriber } from '../chunk-332NNKOW.js';
+import '../chunk-NXYS73I4.js';
+import '../chunk-JDL3U4OX.js';
+import '../chunk-LD2DWZRJ.js';
+import '../chunk-LTYMA4U4.js';
+import '../chunk-DN5B6PRW.js';
+import '../chunk-6225YMFE.js';
+import '../chunk-7QVYU63E.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/esm/types/index.d.mts

@@ -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/esm/types/index.js

@@ -0,0 +1,4 @@
+export { DEFAULT_CONFIG, UploadState } from '../chunk-X757PBC5.js';
+import '../chunk-7QVYU63E.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/esm/utils/index.d.mts

@@ -0,0 +1,72 @@
+import { ChunkSizeConfig } from '../types/index.mjs';
+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/esm/utils/index.js

@@ -0,0 +1,5 @@
+export { ChunkFormDataBuilder, ExponentialBackoffStrategy, FileUtils, LinearBackoffStrategy, createChunkFormData, updateProgressBarHTMLNotified } from '../chunk-MFYC4PBP.js';
+import '../chunk-X757PBC5.js';
+import '../chunk-7QVYU63E.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/esm/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}