upload-sdk 1.0.0

package/utils/index.d.ts

@@ -0,0 +1,108 @@
+/**
+ * 动态创建 web worker
+ */
+declare class DynamicWorker {
+    core: string;
+    blob: Blob;
+    url: string;
+    worker: any;
+    constructor(core: any);
+    send(data: Record<string, any>): void;
+    onMessage(callback: (data: Record<string, any>) => void): void;
+    close(): void;
+}
+
+declare class FileHashWorker extends DynamicWorker {
+    constructor();
+}
+
+declare class FileChunkHashWorker extends DynamicWorker {
+    constructor();
+}
+
+declare const fileChunkHashWorkerCode = "\n  importScripts('https://cdn.jsdelivr.net/npm/spark-md5@3.0.2/spark-md5.min.js');\n  self.onmessage = async function(e) {\n    const { file, chunkSize, index, startChunksIndex, endChunksIndex } = e.data\n    const promises = []\n    for (let i = startChunksIndex; i < endChunksIndex; i++) {\n        const promise = new Promise((resolve, reject) => {\n            const spark = new self.SparkMD5.ArrayBuffer()\n            const start = i * chunkSize\n            const end = Math.min(start + chunkSize, file.size)\n            const blob = file.slice(start, end)\n\n            const reader = new FileReader()\n            reader.onload = (event) => {\n                spark.append(event.target.result)\n                const chunk = {\n                    fileHash: spark.end(),\n                    chunkIndex: i,\n                    chunkSize: chunkSize,\n                    blob: blob,\n                    result: event.target.result\n                }\n                self.postMessage({\n                    type: 'COMPLETE_CHUNK',\n                    data: {\n                        index: index,\n                        chunk: chunk\n                    }\n                })\n                resolve(chunk)\n            }\n\n            reader.onerror = (event) => {\n                reject(event.target.error)\n            }\n            reader.readAsArrayBuffer(blob)\n        })\n        promises.push(promise)\n    }\n\n    const allChunks = await Promise.all(promises)\n    self.postMessage({\n        type: 'COMPLETE_CHUNKS',\n        data: {\n            index: index,\n            chunks: allChunks\n        }\n    })\n  }\n";
+declare const fileHashWorkerCode = "\n  importScripts('https://cdn.jsdelivr.net/npm/spark-md5@3.0.2/spark-md5.min.js');\n  function calculateFileMd5(file) {\n    return new Promise((resolve) => {\n        const spark = new SparkMD5.ArrayBuffer();\n        const reader = new FileReader();\n        const chunkSize = 500 * 1024;\n        let currentChunk = 0;\n        const totalChunks = Math.ceil(file.size / chunkSize);\n        // \u5206\u7247\u8BFB\u53D6\u6587\u4EF6\u5185\u5BB9\n        function loadNextChunk() {\n            const start = currentChunk * chunkSize;\n            const end = Math.min(start + chunkSize, file.size);\n            reader.readAsArrayBuffer(file.slice(start, end));\n        }\n\n        reader.onload = (e) => {\n            spark.append(e.target.result); // \u8FFD\u52A0\u5206\u7247\u5185\u5BB9\u5230MD5\u8BA1\u7B97\n            currentChunk++;\n            if (currentChunk < totalChunks) {\n                loadNextChunk(); // \u7EE7\u7EED\u8BFB\u53D6\u4E0B\u4E00\u4E2A\u5206\u7247\n            } else {\n                const md5 = spark.end(); // \u8BA1\u7B97\u5B8C\u6210\uFF0C\u5F97\u5230\u6700\u7EC8MD5\n                resolve(md5);\n            }\n        };\n        loadNextChunk();\n    });\n  }\n\n  self.onmessage = async function(e) {\n    const { file, chunkSize } = e.data\n    const fileHash = await calculateFileMd5(file)\n    console.log('fileHash', fileHash)\n    self.postMessage({\n        data: {\n            fileHash: fileHash\n        }\n    })\n  }\n";
+
+interface RequestConfig {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'PATCH';
+    baseURL?: string;
+    headers?: Record<string, string>;
+    params?: Record<string, any>;
+    data?: any;
+    timeout?: number;
+    responseType?: 'json' | 'text' | 'blob' | 'arraybuffer' | 'stream';
+    withCredentials?: boolean;
+    adapter?: 'fetch' | 'axios' | 'uni';
+    validateStatus?: (status: number) => boolean;
+    onUploadProgress?: (progressEvent: any) => void;
+    onDownloadProgress?: (progressEvent: any) => void;
+    cancelToken?: any;
+}
+interface Response<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    config: RequestConfig;
+    request?: any;
+}
+interface HttpClientInstance {
+    request<T = any>(config: RequestConfig): Promise<Response<T>>;
+    get<T = any>(url: string, config?: RequestConfig): Promise<Response<T>>;
+    post<T = any>(url: string, data?: any, config?: RequestConfig): Promise<Response<T>>;
+    put<T = any>(url: string, data?: any, config?: RequestConfig): Promise<Response<T>>;
+    delete<T = any>(url: string, config?: RequestConfig): Promise<Response<T>>;
+    patch<T = any>(url: string, data?: any, config?: RequestConfig): Promise<Response<T>>;
+}
+
+declare class HttpClient implements HttpClientInstance {
+    private adapter;
+    private defaultConfig;
+    private interceptors;
+    constructor(config?: Partial<RequestConfig>);
+    /**
+     * 核心请求方法
+     */
+    request<T = any>(config: RequestConfig): Promise<Response<T>>;
+    /**
+     * 快捷方法
+     */
+    get<T = any>(url: string, config?: RequestConfig): Promise<Response<T>>;
+    post<T = any>(url: string, data?: any, config?: RequestConfig): Promise<Response<T>>;
+    put<T = any>(url: string, data?: any, config?: RequestConfig): Promise<Response<T>>;
+    delete<T = any>(url: string, config?: RequestConfig): Promise<Response<T>>;
+    patch<T = any>(url: string, data?: any, config?: RequestConfig): Promise<Response<T>>;
+    /**
+     * 添加请求拦截器
+     */
+    addRequestInterceptor(interceptor: (config: RequestConfig) => RequestConfig | Promise<RequestConfig>): void;
+    /**
+     * 添加响应拦截器
+     */
+    addResponseInterceptor(interceptor: (response: Response) => Response | Promise<Response>): void;
+    /**
+     * 切换适配器
+     */
+    setAdapter(adapterName: 'fetch' | 'axios' | 'uni'): void;
+    /**
+     * 获取当前适配器名称
+     */
+    getAdapterName(): string;
+}
+
+declare function createHttpClient(config?: Partial<RequestConfig>): HttpClient;
+
+declare class TaskQueue {
+    tasks: any[];
+}
+
+declare const isH5: false | {
+    <K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementTagNameMap[K];
+    <K extends keyof HTMLElementDeprecatedTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementDeprecatedTagNameMap[K];
+    (tagName: string, options?: ElementCreationOptions): HTMLElement;
+};
+declare const isWeb: boolean;
+declare const isUniApp: boolean;
+
+export { DynamicWorker, FileChunkHashWorker, FileHashWorker, TaskQueue, createHttpClient, fileChunkHashWorkerCode as defineFileChunkHashWorkerCode, fileHashWorkerCode as defineFileHashWorkerCode, isH5, isUniApp, isWeb };

package/utils/index.esm.js

@@ -0,0 +1,572 @@
+/**
+ * 动态创建 web worker
+ */
+class DynamicWorker {
+    constructor(core) {
+        this.core = core.toString();
+        this.blob = new Blob([`(()=>{${this.core}})()`], { type: "text/javascript" });
+        this.url = URL.createObjectURL(this.blob);
+        this.worker = new Worker(this.url);
+    }
+    // 发送到 web worker
+    send(data) {
+        if (!this.worker) {
+            console.error("worker is not ready");
+            return;
+        }
+        this.worker.postMessage(data);
+    }
+    // 接收到 web worker 的消息
+    onMessage(callback) {
+        if (!this.worker) {
+            console.error("worker is not ready");
+            return;
+        }
+        this.worker.addEventListener("message", (e) => {
+            callback(e.data);
+        });
+    }
+    // 关闭 web worker
+    close() {
+        URL.revokeObjectURL(this.url);
+        if (this.worker) {
+            this.worker.terminate();
+            this.worker = null;
+        }
+    }
+}
+
+const fileChunkHashWorkerCode = `
+  importScripts('https://cdn.jsdelivr.net/npm/spark-md5@3.0.2/spark-md5.min.js');
+  self.onmessage = async function(e) {
+    const { file, chunkSize, index, startChunksIndex, endChunksIndex } = e.data
+    const promises = []
+    for (let i = startChunksIndex; i < endChunksIndex; i++) {
+        const promise = new Promise((resolve, reject) => {
+            const spark = new self.SparkMD5.ArrayBuffer()
+            const start = i * chunkSize
+            const end = Math.min(start + chunkSize, file.size)
+            const blob = file.slice(start, end)
+
+            const reader = new FileReader()
+            reader.onload = (event) => {
+                spark.append(event.target.result)
+                const chunk = {
+                    fileHash: spark.end(),
+                    chunkIndex: i,
+                    chunkSize: chunkSize,
+                    blob: blob,
+                    result: event.target.result
+                }
+                self.postMessage({
+                    type: 'COMPLETE_CHUNK',
+                    data: {
+                        index: index,
+                        chunk: chunk
+                    }
+                })
+                resolve(chunk)
+            }
+
+            reader.onerror = (event) => {
+                reject(event.target.error)
+            }
+            reader.readAsArrayBuffer(blob)
+        })
+        promises.push(promise)
+    }
+
+    const allChunks = await Promise.all(promises)
+    self.postMessage({
+        type: 'COMPLETE_CHUNKS',
+        data: {
+            index: index,
+            chunks: allChunks
+        }
+    })
+  }
+`;
+const fileHashWorkerCode = `
+  importScripts('https://cdn.jsdelivr.net/npm/spark-md5@3.0.2/spark-md5.min.js');
+  function calculateFileMd5(file) {
+    return new Promise((resolve) => {
+        const spark = new SparkMD5.ArrayBuffer();
+        const reader = new FileReader();
+        const chunkSize = 500 * 1024;
+        let currentChunk = 0;
+        const totalChunks = Math.ceil(file.size / chunkSize);
+        // 分片读取文件内容
+        function loadNextChunk() {
+            const start = currentChunk * chunkSize;
+            const end = Math.min(start + chunkSize, file.size);
+            reader.readAsArrayBuffer(file.slice(start, end));
+        }
+
+        reader.onload = (e) => {
+            spark.append(e.target.result); // 追加分片内容到MD5计算
+            currentChunk++;
+            if (currentChunk < totalChunks) {
+                loadNextChunk(); // 继续读取下一个分片
+            } else {
+                const md5 = spark.end(); // 计算完成，得到最终MD5
+                resolve(md5);
+            }
+        };
+        loadNextChunk();
+    });
+  }
+
+  self.onmessage = async function(e) {
+    const { file, chunkSize } = e.data
+    const fileHash = await calculateFileMd5(file)
+    console.log('fileHash', fileHash)
+    self.postMessage({
+        data: {
+            fileHash: fileHash
+        }
+    })
+  }
+`;
+
+class FileHashWorker extends DynamicWorker {
+    constructor() {
+        super(fileHashWorkerCode);
+    }
+}
+
+class FileChunkHashWorker extends DynamicWorker {
+    constructor() {
+        super(fileChunkHashWorkerCode);
+    }
+}
+
+class FetchAdapter {
+    constructor() {
+        this.name = 'fetch';
+    }
+    isAvailable() {
+        return typeof fetch !== 'undefined' && typeof window !== 'undefined';
+    }
+    async request(config) {
+        const { url, method = 'GET', headers = {}, data, params, timeout = 30000, responseType = 'json', withCredentials = false, } = config;
+        // 处理 URL 参数
+        let fullUrl = this.buildFullUrl(url, config.baseURL);
+        if (params) {
+            fullUrl = this.appendParams(fullUrl, params);
+        }
+        // 创建请求配置
+        const fetchConfig = {
+            method: method.toUpperCase(),
+            headers: this.normalizeHeaders(headers),
+            credentials: withCredentials ? 'include' : 'same-origin',
+        };
+        // 处理请求体
+        if (data) {
+            fetchConfig.body = this.processRequestBody(data, headers);
+        }
+        // 超时处理
+        const controller = new AbortController();
+        fetchConfig.signal = controller.signal;
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            const response = await fetch(fullUrl, fetchConfig);
+            clearTimeout(timeoutId);
+            // 处理响应
+            const responseData = await this.processResponse(response, responseType);
+            const responseHeaders = this.extractHeaders(response.headers);
+            return {
+                data: responseData,
+                status: response.status,
+                statusText: response.statusText,
+                headers: responseHeaders,
+                config,
+                request: null,
+            };
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error.name === 'AbortError') {
+                throw new Error(`Request timeout after ${timeout}ms`);
+            }
+            throw error;
+        }
+    }
+    buildFullUrl(url, baseURL) {
+        if (baseURL) {
+            return baseURL.replace(/\/+$/, '') + '/' + url.replace(/^\/+/, '');
+        }
+        return url;
+    }
+    appendParams(url, params) {
+        const urlObj = new URL(url, window.location.origin);
+        Object.keys(params).forEach(key => {
+            if (params[key] !== undefined && params[key] !== null) {
+                urlObj.searchParams.append(key, String(params[key]));
+            }
+        });
+        return urlObj.toString();
+    }
+    normalizeHeaders(headers) {
+        const normalized = {};
+        Object.keys(headers).forEach(key => {
+            const value = headers[key];
+            if (value !== undefined && value !== null) {
+                normalized[key] = String(value);
+            }
+        });
+        // 如果没有 Content-Type 且不是 FormData，默认添加
+        if (!normalized['Content-Type'] && !normalized['content-type']) {
+            normalized['Content-Type'] = 'application/json';
+        }
+        return normalized;
+    }
+    processRequestBody(data, headers) {
+        const contentType = headers['Content-Type'] || headers['content-type'];
+        if (data instanceof FormData || data instanceof URLSearchParams) {
+            return data;
+        }
+        if (contentType?.includes('application/json')) {
+            return JSON.stringify(data);
+        }
+        if (contentType?.includes('application/x-www-form-urlencoded')) {
+            return new URLSearchParams(data).toString();
+        }
+        return String(data);
+    }
+    async processResponse(response, responseType) {
+        switch (responseType) {
+            case 'json':
+                return response.json();
+            case 'text':
+                return response.text();
+            case 'blob':
+                return response.blob();
+            case 'arraybuffer':
+                return response.arrayBuffer();
+            default:
+                return response.text();
+        }
+    }
+    extractHeaders(headers) {
+        const result = {};
+        headers.forEach((value, key) => {
+            result[key] = value;
+        });
+        return result;
+    }
+}
+
+class AxiosAdapter {
+    constructor() {
+        this.name = 'axios';
+    }
+    isAvailable() {
+        try {
+            return typeof require !== 'undefined' && !!require('axios') ||
+                (typeof window !== 'undefined' && !!window.axios);
+        }
+        catch {
+            return false;
+        }
+    }
+    async request(config) {
+        const axios = await this.getAxios();
+        try {
+            const response = await axios({
+                url: config.url,
+                method: config.method,
+                baseURL: config.baseURL,
+                headers: config.headers,
+                params: config.params,
+                data: config.data,
+                timeout: config.timeout,
+                responseType: config.responseType,
+                withCredentials: config.withCredentials,
+                onUploadProgress: config.onUploadProgress,
+                onDownloadProgress: config.onDownloadProgress,
+                cancelToken: config.cancelToken,
+                validateStatus: config.validateStatus,
+            });
+            return {
+                data: response.data,
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                config: response.config,
+                request: response.request,
+            };
+        }
+        catch (error) {
+            if (error.response) {
+                throw {
+                    data: error.response.data,
+                    status: error.response.status,
+                    statusText: error.response.statusText,
+                    headers: error.response.headers,
+                    config: error.response.config,
+                };
+            }
+            throw error;
+        }
+    }
+    async getAxios() {
+        // 动态导入 axios
+        if (typeof window !== 'undefined' && window.axios) {
+            return window.axios;
+        }
+        if (typeof require !== 'undefined') {
+            return require('axios');
+        }
+        throw new Error('Axios is not available');
+    }
+}
+
+class UniAdapter {
+    constructor() {
+        this.name = 'uni';
+    }
+    isAvailable() {
+        return typeof uni !== 'undefined' && typeof uni.request === 'function';
+    }
+    request(config) {
+        return new Promise((resolve, reject) => {
+            if (!uni || !uni.request) {
+                reject(new Error('uni.request is not available'));
+                return;
+            }
+            const { url, method = 'GET', headers = {}, data, timeout = 30000, responseType = 'json', withCredentials = false, } = config;
+            const uniConfig = {
+                url: this.buildFullUrl(url, config.baseURL),
+                method: method.toUpperCase(),
+                header: headers,
+                data,
+                timeout,
+                dataType: responseType === 'json' ? 'json' : 'text',
+                responseType: responseType === 'arraybuffer' ? 'arraybuffer' : 'text',
+                sslVerify: true,
+                withCredentials,
+                firstIpv4: false,
+            };
+            // 处理参数
+            if (config.params) {
+                uniConfig.url = this.appendParams(uniConfig.url, config.params);
+            }
+            uni.request({
+                ...uniConfig,
+                success: (res) => {
+                    resolve({
+                        data: res.data,
+                        status: res.statusCode,
+                        statusText: this.getStatusText(res.statusCode),
+                        headers: res.header,
+                        config,
+                        request: null,
+                    });
+                },
+                fail: (err) => {
+                    reject(new Error(err.errMsg || 'uni.request failed'));
+                },
+            });
+        });
+    }
+    buildFullUrl(url, baseURL) {
+        if (baseURL) {
+            return baseURL.replace(/\/+$/, '') + '/' + url.replace(/^\/+/, '');
+        }
+        return url;
+    }
+    appendParams(url, params) {
+        const paramStr = Object.keys(params)
+            .filter(key => params[key] !== undefined && params[key] !== null)
+            .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
+            .join('&');
+        return url + (url.includes('?') ? '&' : '?') + paramStr;
+    }
+    getStatusText(status) {
+        const statusMap = {
+            200: 'OK',
+            201: 'Created',
+            400: 'Bad Request',
+            401: 'Unauthorized',
+            403: 'Forbidden',
+            404: 'Not Found',
+            500: 'Internal Server Error',
+        };
+        return statusMap[status] || 'Unknown';
+    }
+}
+
+class AdapterFactory {
+    /**
+     * 自动选择可用的适配器
+     */
+    static getAvailableAdapter() {
+        for (const adapter of this.adapters) {
+            if (adapter.isAvailable()) {
+                console.log(`Using ${adapter.name} adapter`);
+                return adapter;
+            }
+        }
+        throw new Error('No available adapter found');
+    }
+    /**
+     * 获取指定适配器
+     */
+    static getAdapter(name) {
+        const adapter = this.adapters.find(a => a.name === name);
+        if (!adapter) {
+            throw new Error(`Adapter ${name} not found`);
+        }
+        if (!adapter.isAvailable()) {
+            throw new Error(`Adapter ${name} is not available in current environment`);
+        }
+        return adapter;
+    }
+    /**
+     * 注册自定义适配器
+     */
+    static registerAdapter(adapter) {
+        this.adapters.unshift(adapter); // 优先使用自定义适配器
+    }
+}
+AdapterFactory.adapters = [
+    new FetchAdapter(),
+    new AxiosAdapter(),
+    new UniAdapter(),
+];
+
+class HttpClient {
+    constructor(config = {}) {
+        this.defaultConfig = config;
+        this.interceptors = {
+            request: [],
+            response: [],
+        };
+        // 自动选择适配器或使用指定的适配器
+        if (config.adapter) {
+            this.adapter = AdapterFactory.getAdapter(config.adapter);
+        }
+        else {
+            this.adapter = AdapterFactory.getAvailableAdapter();
+        }
+    }
+    /**
+     * 核心请求方法
+     */
+    async request(config) {
+        // 合并配置
+        const mergedConfig = {
+            ...this.defaultConfig,
+            ...config,
+            headers: {
+                ...this.defaultConfig.headers,
+                ...config.headers,
+            },
+        };
+        // 执行请求拦截器
+        let requestConfig = mergedConfig;
+        for (const interceptor of this.interceptors.request) {
+            requestConfig = await interceptor(requestConfig);
+        }
+        // 发送请求
+        const response = await this.adapter.request(requestConfig);
+        // 执行响应拦截器
+        let processedResponse = response;
+        for (const interceptor of this.interceptors.response) {
+            processedResponse = await interceptor(processedResponse);
+        }
+        return processedResponse;
+    }
+    /**
+     * 快捷方法
+     */
+    get(url, config) {
+        return this.request({ ...config, url, method: 'GET' });
+    }
+    post(url, data, config) {
+        return this.request({ ...config, url, method: 'POST', data });
+    }
+    put(url, data, config) {
+        return this.request({ ...config, url, method: 'PUT', data });
+    }
+    delete(url, config) {
+        return this.request({ ...config, url, method: 'DELETE' });
+    }
+    patch(url, data, config) {
+        return this.request({ ...config, url, method: 'PATCH', data });
+    }
+    /**
+     * 添加请求拦截器
+     */
+    addRequestInterceptor(interceptor) {
+        this.interceptors.request.push(interceptor);
+    }
+    /**
+     * 添加响应拦截器
+     */
+    addResponseInterceptor(interceptor) {
+        this.interceptors.response.push(interceptor);
+    }
+    /**
+     * 切换适配器
+     */
+    setAdapter(adapterName) {
+        this.adapter = AdapterFactory.getAdapter(adapterName);
+    }
+    /**
+     * 获取当前适配器名称
+     */
+    getAdapterName() {
+        return this.adapter.name;
+    }
+}
+
+function createHttpClient(config = {}) {
+    const client = new HttpClient(config);
+    // 默认请求拦截器 - 添加认证信息
+    client.addRequestInterceptor(async (config) => {
+        // 从存储中获取 token
+        // const token = localStorage?.getItem('token') || uni?.getStorageSync?.('token');
+        // if (token && !config.headers?.['Authorization']) {
+        //     config.headers = {
+        //         ...config.headers,
+        //         'Authorization': `Bearer ${token}`,
+        //     };
+        // }
+        return config;
+    });
+    // 默认响应拦截器 - 处理业务错误
+    client.addResponseInterceptor(async (response) => {
+        // 如果响应状态码不在 200-299 范围内
+        if (response.status < 200 || response.status >= 300) {
+            throw new Error(`Request failed with status ${response.status}`);
+        }
+        // 处理业务逻辑错误码（根据后端接口规范调整）
+        if (response.data && response.data.code !== 0) {
+            throw new Error(response.data.message || 'Business logic error');
+        }
+        return response;
+    });
+    return client;
+}
+
+class TaskQueue {
+    constructor() {
+        this.tasks = [];
+    }
+}
+
+const useEnv = () => {
+    const isH5 = typeof window !== 'undefined' && window.document && window.document.createElement;
+    const isWeb = typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'development';
+    const isUniApp = typeof uni !== 'undefined';
+    return {
+        isH5,
+        isWeb,
+        isUniApp
+    };
+};
+const { isH5, isWeb, isUniApp } = useEnv();
+
+export { DynamicWorker, FileChunkHashWorker, FileHashWorker, TaskQueue, createHttpClient, fileChunkHashWorkerCode as defineFileChunkHashWorkerCode, fileHashWorkerCode as defineFileHashWorkerCode, isH5, isUniApp, isWeb };
+//# sourceMappingURL=index.esm.js.map