@masvio/uploader/dist/index.d.ts

A simple, lightweight library to easily share files using MASV

declare type AcceptedEvents = string | WorkerEvents | UploaderEvents;

declare interface ChunkedFile extends ChunkResult {
    fileId: string;
    file: MasvFile;
    fileExtras: Record<string, any>;
    storageType: string;
}

declare interface ChunkExtra {
    partNumber: string;
    etag: string | null;
}

declare interface ChunkExtras {
    headers: Record<string, string>;
    req: XhrRequest;
}

declare interface ChunkRequest {
    id: number;
    file: File;
    chunkSize: number;
    blueprints: Array<RequestBlueprint>;
    sequence?: number;
    fileId?: string;
    url: string;
    method: string;
}

declare interface ChunkResult {
    req: ChunkRequest;
    chunks: Array<MasvChunk>;
}

declare class ChunkState {
    private _currentBytes;
    index: number;
    chunk: MasvChunk;
    extras: ChunkExtra | null;
    constructor(chunk: MasvChunk, index: number);
    setProgress(amount: number): void;
    setExtras(chunkExtras: ChunkExtra): void;
    get etag(): string | null | undefined;
    get currentBytes(): number;
    get totalBytes(): number;
    get inProgress(): boolean;
    get isFinished(): boolean;
}

export declare interface ErrorEventRequest {
    error_code: string;
    error_message: string;
    event_time: string;
    extras?: object;
}

export declare interface ErrorEventRequest {
    error_code: string;
    error_message: string;
    event_time: string;
    extras?: object;
}

declare interface EventContent {
    data: object | void;
    target?: object;
}

declare class EventEmitter {
    handlers: HandlerRecord;
    on(name: AcceptedEvents, callback: (payload: EventPayload) => void): void;
    off(name: AcceptedEvents, callback?: (payload: EventPayload) => void): void;
    clearHandlers(): void;
    emit(name: AcceptedEvents, payload?: EventPayload): void;
    bubbleEmit(payload: EventPayload): void;
}

declare type EventPayload = EventWrapper | EventContent;

declare interface EventWrapper {
    time?: number;
    event: AcceptedEvents;
    target: object;
    data?: object;
}

export declare interface FileError {
    id: string;
    name: string;
    path: string;
    size: number;
    errorMessage: string;
    errorTimestamp: string;
}

export declare interface FileError {
    id: string;
    name: string;
    path: string;
    size: number;
    errorMessage: string;
    errorTimestamp: string;
}

declare class FileState {
    id: string;
    file: MasvFile;
    req: ChunkRequest;
    chunks: Array<ChunkState>;
    storageType: string;
    chunkSize: number;
    fileExtras: Record<string, any>;
    running: boolean;
    finalized: boolean;
    constructor({ fileId, req, file, chunks, storageType, fileExtras }: ChunkedFile);
    setChunkExtras({ headers, req }: ChunkExtras): void;
    getChunk(index: number): ChunkState;
    validateMissingEtags(): Array<ChunkState>;
    get isFinished(): boolean;
    get inProgress(): boolean;
    get currentBytes(): number;
    get totalBytes(): number;
    get chunksInProgress(): number;
}

declare type HandlerRecord = Record<AcceptedEvents, Array<(payload: EventPayload) => void>>;

export declare interface IncompleteFiles {
    queued: Array<MasvFile>;
    creating: Array<string>;
    uploading: Array<FileState>;
    unreadable: Array<FileError>;
}

export declare interface MasvChunk {
    body: Blob;
    url: string;
    method: string;
    progress: number;
    headers?: {
        [key: string]: string;
    };
}

export declare interface MasvFile {
    id: string;
    file: File;
    path: string;
}

export declare interface MasvFileUploadInfo {
    file: MasvFile;
    fileId: string;
    storageType: string;
    fileExtras: {
        [key: string]: string;
    };
    chunks: Array<MasvChunk>;
    chunkSize: number;
}

export declare interface PackageSpec {
    max_chunk_count: number;
    max_chunk_size: number;
    min_chunk_size: number;
}

declare interface PerformanceResults {
    duration: number;
    speed: number;
    instant: number;
    moving: number;
    transferred: number;
    total: number;
    totalFiles: number;
    progress: number;
    received: number;
    finalized: number;
    finalizedFiles: number;
}

export declare interface ProgressSummary {
    finalizedBytes: string;
    finalizedFiles: string;
    totalBytes: string;
    totalFiles: string;
    unreadableFiles: string;
}

declare interface RequestBlueprint {
    url: string;
    method: string;
    headers: {
        [key: string]: string;
    };
    body: Blob | string;
}

declare enum RequestTypes {
    AddChunk = "add_chunk",
    UploadFile = "upload_file",
    FinalizeFile = "finalize_file",
    FinalizePackage = "finalize_package",
    CancelPackage = "cancel_package",
    Error = "error"
}

declare interface RetryConfig {
    retries: number;
    delay: number;
}

export declare class Uploader extends EventEmitter {
    private readonly packageID;
    private readonly packageToken;
    private readonly apiBaseUrl;
    private readonly stallTimeout;
    private readonly apiXhrExecutor;
    private readonly storageXhrExecutor;
    private readonly fchunker;
    private readonly fuploader;
    private stallTimer;
    private performanceStats;
    private version;
    private readonly masvUserAgent;
    static readonly UploaderEvents: typeof UploaderEvents;
    uploadState: UploadState;
    private fileQueue;
    private createQueue;
    unreadableFiles: Set<FileError>;
    static readonly States: typeof UploaderStates;
    status: UploaderStates;
    private spec;
    constructor(packageID: string, packageToken: string, apiBaseUrl?: string, chunkSize?: number, masvWebUserAgent?: string, stallTimeout?: number);
    private resetStallTimer;
    private popNextFile;
    private get nextFile();
    private get canUploadFile();
    private get hasFinished();
    private onUploadProgress;
    private onChunkFinish;
    private onUploadAbort;
    private onUploadRetry;
    private onUploadApiError;
    private onUploadError;
    private onChunkUploadFinish;
    private onAPIFinish;
    private setUnreadableFile;
    private markAsStalled;
    addFiles(...files: MasvFile[]): Promise<void>;
    start(): void;
    getSpec(count?: number): Promise<PackageSpec>;
    private uploadNext;
    stop(): void;
    pause(): void;
    terminate(): void;
    cancel(): void;
    private finalizeFile;
    getIncompleteFiles(): IncompleteFiles;
    finalize(): void;
    getPerformanceStats(): PerformanceResults;
    getProgressSummary(): ProgressSummary;
}

declare enum UploaderEvents {
    Created = "uploader:create",
    Start = "upload:start",
    Progress = "upload:progress",
    Chunk = "upload:chunk",
    File = "upload:file",
    Error = "upload:error",
    Finished = "upload:finish",
    Finalize = "upload:finalize",
    FileQueued = "upload:file_queued",
    Abort = "upload:abort",
    Retry = "upload:retry",
    Stalled = "upload:stalled",
    FileUnreadable = "upload:file_unreadable"
}

declare enum UploaderStates {
    Idle = "idle",
    Uploading = "uploading",
    Processing = "processing",
    Ready = "ready",
    Paused = "paused",
    Finished = "finished",
    Terminated = "terminated",
    Cancelled = "cancelled"
}

declare class UploadState {
    queue: Record<string, FileState>;
    getFile(fileId: string): FileState | undefined;
    addFile(file: ChunkedFile): FileState;
    removeFile(fileId: string): void;
    setProgress(fileId: string, chunkIndex: number, amount: number): ChunkState | undefined;
    get length(): number;
    get totalChunks(): number;
    get totalChunksInProgress(): number;
}

declare enum WorkerEvents {
    ApiError = "worker:api_error",
    Created = "worker:create",
    Execute = "worker:execute",
    Finish = "worker:finish",
    Error = "worker:error",
    Retry = "worker:retry",
    Progress = "worker:progress",
    Terminate = "worker:terminate",
    Abort = "worker:abort"
}

declare interface XhrRequest {
    sequence?: number;
    body?: Blob | string;
    timeout?: number;
    retryConfig?: RetryConfig;
    url: string;
    method: string;
    headers?: {
        [key: string]: string;
    };
    fileId?: string;
    type?: RequestTypes;
}

export { }