js-uploader/dist/esm/interface/index.d.ts

A JavaScript library for file upload

/// <reference types="node" />
import type { Stats } from 'fs';
/**
 * 事件类型
 */
export declare enum EventType {
    FileWaiting = "file-waiting",
    FileUploadStart = "file-upload-start",
    FileProgress = "file-progress",
    FilePause = "file-pause",
    FilesPause = "files-pause",
    FileError = "file-error",
    FileCancel = "file-cancel",
    FilesCancel = "files-cancel",
    FileComplete = "file-complete",
    ChunkUploadStart = "chunk-upload-start",
    ChunkError = "chunk-error",
    ChunkComplete = "chunk-complete",
    TaskCreated = "task-created",
    TaskUpdate = "task-update",
    TaskRestore = "task-restore",
    TaskPresist = "task-presist",
    TasksPresist = "tasks-presist",
    TasksAdded = "tasks-added",
    TaskWaiting = "task-waiting",
    TaskUploadStart = "task-upload-start",
    TaskProgress = "task-progress",
    TaskPause = "task-pause",
    TasksPause = "tasks-pause",
    TaskResume = "task-resume",
    TaskRetry = "task-retry",
    TaskError = "task-error",
    TaskCancel = "task-cancel",
    TaskComplete = "task-complete",
    Clear = "clear",
    Complete = "complete"
}
/**
 * 状态码
 */
export declare enum StatusCode {
    Waiting = "waiting",
    Uploading = "uploading",
    Pause = "pause",
    Error = "error",
    Complete = "complete"
}
export declare enum OSSProvider {
    Qiniu = "qiniu",
    Qiniu_v2 = "qiniu_v2",
    S3 = "s3"
}
export declare type ID = string | number;
export declare type Protocol = 'http:' | 'https:';
export declare type RequestMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
export declare type OSS = OSSProvider;
export declare type Obj = {
    [key: string]: any;
};
export declare type FileStatus = StatusCode;
export declare type ChunkStatus = StatusCode;
export declare type TaskStatus = StatusCode;
/**
 * 文件分块
 */
export interface FileChunk {
    id: ID;
    start: number;
    end: number;
    index: number;
    data: Nullable<Blob>;
    hash: string;
    uploaded: number;
    size: number;
    progress: number;
    status: ChunkStatus;
    response: Obj;
    extraInfo: Obj;
}
/**
 * 上传文件
 */
export interface UploadFile {
    id: ID;
    name: string;
    type: string;
    size: number;
    relativePath: string;
    path: string;
    lastModified: number;
    hash: string;
    raw: Nullable<Blob>;
    uploaded: number;
    chunkIDList: ID[];
    chunkList: FileChunk[];
    progress: number;
    status: FileStatus;
    response: Obj;
    extraInfo: Obj;
}
/**
 * 任务类型（文件或文件夹）
 */
export declare type TaskType = 'file' | 'dir';
/**
 * 上传任务
 */
export interface UploadTask {
    id: ID;
    name: string;
    type: TaskType;
    fileIDList: ID[];
    fileList: UploadFile[];
    fileSize: number;
    uploaded: number;
    oss?: Nullable<OSS>;
    progress: number;
    status: TaskStatus;
    addTime: Date;
    extraInfo: Obj;
}
/**
 * 文件选择器配置
 */
export interface FilePickerOptions {
    $el: HTMLInputElement | string;
    multiple?: boolean;
    directory?: boolean;
    accept?: string[];
}
/**
 * 文件拖拽器配置
 */
export interface FileDraggerOptions {
    $el: HTMLElement;
    onDragover?: DragEventHandler;
    onDragenter?: DragEventHandler;
    onDragleave?: DragEventHandler;
    onDrop?: DragEventHandler;
}
export declare type DragEventHandler = (event: DragEvent) => void;
export declare type MaybePromise = Promise<any> | void;
export interface OssOptions {
    enable: (task: UploadTask) => TPromise<boolean>;
    provider?: Nullable<OSSProvider>;
    s3Config?: S3Config | (() => TPromise<S3Config>);
    keyGenerator?: (file: UploadFile, task: UploadTask) => TPromise<string>;
    uptokenGenerator?: (file: UploadFile, task: UploadTask) => TPromise<string>;
    bucket?: string | (() => TPromise<string>);
}
export declare type TPromise<T> = T | Promise<T>;
export declare type ResponseType = 'json' | 'text';
export interface RequestOptions {
    url: string | ((task: UploadTask, upfile: UploadFile, chunk: FileChunk) => TPromise<string>);
    headers?: Obj | ((task: UploadTask, upfile: UploadFile, chunk: FileChunk) => TPromise<Obj>);
    body?: Obj | ((task: UploadTask, upfile: UploadFile, chunk: FileChunk, params: Obj) => TPromise<Obj>);
    method?: RequestMethod | ((task: UploadTask, upfile: UploadFile, chunk: FileChunk) => TPromise<RequestMethod>);
    responseType?: ResponseType | ((task: UploadTask, upfile: UploadFile, chunk: FileChunk) => TPromise<ResponseType>);
    timeout?: number;
    withCredentials?: boolean;
}
export interface AjaxResponse {
    originalEvent: Event;
    xhr: XMLHttpRequest;
    request?: any;
    status: number;
    response: any;
    responseText: string;
    responseType: string;
}
/**
 * 文件上传器配置
 */
export interface UploaderOptions {
    id?: ID;
    requestOptions: RequestOptions;
    ossOptions?: OssOptions;
    singleFileTask?: boolean;
    computeFileHash?: boolean;
    computeChunkHash?: boolean;
    autoUpload?: boolean;
    maxRetryTimes?: number;
    retryInterval?: number;
    resumable?: boolean;
    chunked?: boolean;
    chunkSize?: number;
    chunkConcurrency?: number;
    fileConcurrency?: number;
    taskConcurrency?: number;
    skipFileWhenUploadError?: boolean;
    skipTaskWhenUploadError?: boolean;
    filePicker?: FilePickerOptions | FilePickerOptions[];
    fileDragger?: FileDraggerOptions | FileDraggerOptions[];
    fileFilter?: RegExp | ((fileName: string, file: File | string) => boolean);
    recoverableTaskStatus?: StatusCode[];
    readdirFn?: (path: string) => TPromise<string[]>;
    fileStatFn?: (path: string) => TPromise<Stats>;
    readFileFn?: (task: UploadTask, upfile: UploadFile, start?: number, end?: number) => TPromise<Blob>;
    requestBodyProcessFn?: (task: UploadTask, upfile: UploadFile, chunk: FileChunk, params: Obj) => TPromise<any>;
    beforeParseDataTransfer?: (e: DragEvent) => MaybePromise;
    beforeFilesAdd?: (files: File[]) => MaybePromise;
    filesAdded?: (files: UploadFile[]) => MaybePromise;
    beforeTasksAdd?: (tasks: UploadTask[]) => MaybePromise;
    beforeTaskStart?: (task: UploadTask) => MaybePromise;
    beforeFileUploadStart?: (task: UploadTask, file: UploadFile) => MaybePromise;
    beforeFileHashCompute?: (task: UploadTask, file: UploadFile) => MaybePromise;
    fileHashComputed?: (task: UploadTask, file: UploadFile, hash: string) => MaybePromise;
    beforeFileRead?: (task: UploadTask, file: UploadFile, chunk: FileChunk) => MaybePromise;
    fileReaded?: (task: UploadTask, file: UploadFile, chunk: FileChunk, data: Blob) => MaybePromise;
    beforeUploadRequestSend?: (task: UploadTask, file: UploadFile, chunk: FileChunk, requestParams: Obj) => MaybePromise;
    beforeUploadResponseProcess?: (task: UploadTask, file: UploadFile, chunk: FileChunk, response: AjaxResponse) => MaybePromise;
    beforeFileUploadComplete?: (task: UploadTask, file: UploadFile) => MaybePromise;
}
export declare type RequestOpts = {
    url: string;
    headers: Obj;
    body: UploadFormData;
    method?: RequestMethod;
    responseType?: 'json' | 'text';
};
export interface ChunkResponse {
    chunk: FileChunk;
    response?: AjaxResponse;
}
export interface ProgressPayload {
    task: UploadTask;
    file: UploadFile;
    chunk: FileChunk;
    event: ProgressEvent;
}
/**
 * request基本参数
 */
export interface BaseParams {
    chunkIndex: number;
    chunkSize: number;
    currentChunkSize: number;
    fileID: ID;
    fileName: string;
    fileSize: number;
    relativePath: string;
    chunkCount: number;
    fileHash?: string;
    chunkHash?: string;
}
export interface UploadFormData extends BaseParams {
    file?: Blob;
    [key: string]: any;
}
export interface Credentials {
    readonly accessKeyId: string;
    readonly secretAccessKey: string;
    readonly sessionToken?: string;
    readonly expiration?: Date;
}
export interface HeaderBag {
    [key: string]: string;
}
export interface HttpMessage {
    headers: HeaderBag;
    body?: any;
}
export interface HttpRequest extends HttpMessage, Endpoint {
    method: string;
}
export interface QueryParameterBag {
    [key: string]: string | Array<string> | null;
}
export interface Endpoint {
    protocol: string;
    hostname: string;
    port?: number;
    path?: string;
    query?: QueryParameterBag;
}
export interface RequestToSign {
    url: string;
    method: string;
    query?: QueryParameterBag;
    headers?: HeaderBag;
    body?: any;
}
export interface CompletedPart {
    ETag: string;
    PartNumber: number;
}
export interface S3Config {
    region: string;
    credentials: Credentials;
    endpoint: Endpoint;
}