uploader-sdk 1.0.0

package/dist/react-hooks.js

@@ -0,0 +1,344 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { addFiles as sdkAddFiles, cancelFileUpload, clearFiles as sdkClearFiles, createUploadClient, listFiles as sdkListFiles, pauseFileUpload, registerStorageAdapter, resumeFileUpload, setFileExtensionRules, uploadFiles as sdkUploadFiles, uploadSelectedFiles as sdkUploadSelectedFiles, } from './index';
+function mergeUploadOptions(defaults, overrides) {
+    return {
+        parallel: overrides?.parallel ?? defaults?.parallel ?? 3,
+        retry: overrides?.retry ?? defaults?.retry ?? 2,
+        retryDelayMs: overrides?.retryDelayMs ?? defaults?.retryDelayMs ?? 300,
+    };
+}
+function buildStatus(state, progress, totalBytes, error, retryMeta) {
+    const bounded = Math.max(0, Math.min(100, Number.isFinite(progress) ? progress : 0));
+    const safeTotal = Math.max(0, Number.isFinite(totalBytes) ? totalBytes : 0);
+    const uploadedBytes = safeTotal > 0 ? Math.round((bounded / 100) * safeTotal) : 0;
+    return {
+        state,
+        progress: bounded,
+        uploadedBytes,
+        totalBytes: safeTotal,
+        error,
+        retryAttempt: retryMeta?.attempt,
+        maxRetries: retryMeta?.maxRetries,
+    };
+}
+export function useUploader(config) {
+    const [files, setFiles] = useState([]);
+    const [statusById, setStatusById] = useState({});
+    const [logs, setLogs] = useState([]);
+    const [isUploading, setIsUploading] = useState(false);
+    const [pausedById, setPausedById] = useState({});
+    const pausedByIdRef = useRef({});
+    const client = useMemo(() => createUploadClient({
+        dbName: config.dbName,
+        storeName: config.storeName,
+    }), [config.dbName, config.storeName]);
+    const log = useCallback((message) => {
+        setLogs((prev) => [...prev, message]);
+    }, []);
+    useEffect(() => {
+        pausedByIdRef.current = pausedById;
+    }, [pausedById]);
+    useEffect(() => {
+        if (config.adapter) {
+            registerStorageAdapter(client, config.adapterName, config.adapter);
+        }
+    }, [client, config.adapterName, config.adapter]);
+    useEffect(() => {
+        if (config.rules) {
+            setFileExtensionRules(client, {
+                allowExtensions: config.rules.allowExtensions,
+            });
+        }
+    }, [client, config.rules]);
+    const refresh = useCallback(async () => {
+        const stored = (await sdkListFiles(client));
+        setFiles(stored);
+        setStatusById((prev) => {
+            const next = { ...prev };
+            for (const f of stored) {
+                if (!next[f.id]) {
+                    next[f.id] = buildStatus('pending', 0, f.size);
+                }
+                else {
+                    next[f.id] = {
+                        ...next[f.id],
+                        totalBytes: f.size,
+                    };
+                }
+            }
+            for (const id of Object.keys(next)) {
+                if (!stored.find((f) => f.id === id)) {
+                    delete next[id];
+                }
+            }
+            return next;
+        });
+        setPausedById((prev) => {
+            const next = { ...prev };
+            for (const id of Object.keys(next)) {
+                if (!stored.find((f) => f.id === id)) {
+                    delete next[id];
+                }
+            }
+            return next;
+        });
+        return stored;
+    }, [client]);
+    useEffect(() => {
+        if (config.autoRefreshOnMount === false) {
+            return;
+        }
+        void refresh();
+    }, [refresh, config.autoRefreshOnMount]);
+    const addFiles = useCallback(async (selected) => {
+        const result = await sdkAddFiles(client, selected);
+        await refresh();
+        return result;
+    }, [client, refresh]);
+    const clearFiles = useCallback(async () => {
+        await sdkClearFiles(client);
+        setStatusById({});
+        setPausedById({});
+        await refresh();
+    }, [client, refresh]);
+    const setRules = useCallback((rules) => {
+        setFileExtensionRules(client, {
+            allowExtensions: rules.allowExtensions,
+        });
+    }, [client]);
+    const pause = useCallback((fileId) => {
+        pauseFileUpload(client, fileId);
+        setPausedById((prev) => ({ ...prev, [fileId]: true }));
+        setStatusById((prev) => {
+            const current = prev[fileId] ?? buildStatus('pending', 0, 0);
+            return {
+                ...prev,
+                [fileId]: {
+                    ...current,
+                    state: 'paused',
+                },
+            };
+        });
+    }, [client]);
+    const resume = useCallback((fileId) => {
+        resumeFileUpload(client, fileId);
+        setPausedById((prev) => ({ ...prev, [fileId]: false }));
+        setStatusById((prev) => {
+            const current = prev[fileId] ?? buildStatus('pending', 0, 0);
+            const nextState = current.progress > 0 && current.progress < 100 ? 'uploading' : current.progress >= 100 ? 'uploaded' : 'queued';
+            return {
+                ...prev,
+                [fileId]: {
+                    ...current,
+                    state: nextState,
+                },
+            };
+        });
+    }, [client]);
+    const cancel = useCallback(async (fileId) => {
+        await cancelFileUpload(client, fileId);
+        setPausedById((prev) => {
+            const next = { ...prev };
+            delete next[fileId];
+            return next;
+        });
+        setStatusById((prev) => {
+            const next = { ...prev };
+            delete next[fileId];
+            return next;
+        });
+        await refresh();
+    }, [client, refresh]);
+    const uploadAll = useCallback(async (options) => {
+        const current = (await sdkListFiles(client));
+        if (!current.length) {
+            return;
+        }
+        setIsUploading(true);
+        const fileById = new Map(current.map((f) => [f.id, f]));
+        setStatusById((prev) => {
+            const next = { ...prev };
+            for (const file of current) {
+                const isPaused = pausedByIdRef.current[file.id];
+                next[file.id] = buildStatus(isPaused ? 'paused' : 'queued', 0, file.size);
+            }
+            return next;
+        });
+        const merged = mergeUploadOptions(config.defaultUploadOptions, options);
+        try {
+            await sdkUploadFiles(client, config.adapterName, {
+                ...merged,
+                onProgress: (progress, _fileName, meta) => {
+                    const id = meta?.fileId;
+                    if (!id) {
+                        return;
+                    }
+                    const total = fileById.get(id)?.size ?? 0;
+                    const paused = !!pausedByIdRef.current[id];
+                    setStatusById((prev) => ({
+                        ...prev,
+                        [id]: {
+                            ...(prev[id] ?? buildStatus('pending', 0, total)),
+                            ...buildStatus(paused ? 'paused' : progress < 100 ? 'uploading' : 'uploaded', progress, total),
+                        },
+                    }));
+                },
+                onRetry: (error, fileName, meta) => {
+                    const id = meta?.fileId;
+                    if (!id) {
+                        return;
+                    }
+                    const total = fileById.get(id)?.size ?? 0;
+                    setStatusById((prev) => ({
+                        ...prev,
+                        [id]: {
+                            ...(prev[id] ?? buildStatus('pending', 0, total)),
+                            ...buildStatus('retrying', prev[id]?.progress ?? 0, total, error.message, {
+                                attempt: meta.attempt,
+                                maxRetries: meta.maxRetries,
+                            }),
+                        },
+                    }));
+                    log(`Retrying: ${fileName} (${meta.attempt}/${meta.maxRetries}) - ${error.message}`);
+                },
+                onError: (error, fileName, meta) => {
+                    const id = meta?.fileId;
+                    if (id) {
+                        const total = fileById.get(id)?.size ?? 0;
+                        setStatusById((prev) => ({
+                            ...prev,
+                            [id]: {
+                                ...(prev[id] ?? buildStatus('pending', 0, total)),
+                                ...buildStatus('failed', prev[id]?.progress ?? 0, total, error.message),
+                            },
+                        }));
+                    }
+                    log(`Failed after retries: ${fileName} (${error.message})`);
+                },
+                onComplete: (fileName, url, meta) => {
+                    const id = meta?.fileId;
+                    if (id) {
+                        const total = fileById.get(id)?.size ?? 0;
+                        setStatusById((prev) => ({
+                            ...prev,
+                            [id]: {
+                                ...(prev[id] ?? buildStatus('pending', 0, total)),
+                                ...buildStatus('uploaded', 100, total),
+                            },
+                        }));
+                    }
+                    log(`Uploaded: ${fileName} -> ${url}`);
+                },
+            });
+        }
+        finally {
+            setIsUploading(false);
+            await refresh();
+        }
+    }, [client, config.adapterName, config.defaultUploadOptions, refresh, log]);
+    const uploadSelected = useCallback(async (fileIds, options) => {
+        if (!fileIds.length) {
+            return;
+        }
+        const current = (await sdkListFiles(client));
+        const fileById = new Map(current.map((f) => [f.id, f]));
+        const idSet = new Set(fileIds);
+        setIsUploading(true);
+        setStatusById((prev) => {
+            const next = { ...prev };
+            for (const id of idSet) {
+                const total = fileById.get(id)?.size ?? 0;
+                const paused = !!pausedByIdRef.current[id];
+                next[id] = buildStatus(paused ? 'paused' : 'queued', 0, total);
+            }
+            return next;
+        });
+        const merged = mergeUploadOptions(config.defaultUploadOptions, options);
+        try {
+            await sdkUploadSelectedFiles(client, config.adapterName, fileIds, {
+                ...merged,
+                onProgress: (progress, _fileName, meta) => {
+                    const id = meta?.fileId;
+                    if (!id) {
+                        return;
+                    }
+                    const total = fileById.get(id)?.size ?? 0;
+                    const paused = !!pausedByIdRef.current[id];
+                    setStatusById((prev) => ({
+                        ...prev,
+                        [id]: {
+                            ...(prev[id] ?? buildStatus('pending', 0, total)),
+                            ...buildStatus(paused ? 'paused' : progress < 100 ? 'uploading' : 'uploaded', progress, total),
+                        },
+                    }));
+                },
+                onRetry: (error, fileName, meta) => {
+                    const id = meta?.fileId;
+                    if (!id) {
+                        return;
+                    }
+                    const total = fileById.get(id)?.size ?? 0;
+                    setStatusById((prev) => ({
+                        ...prev,
+                        [id]: {
+                            ...(prev[id] ?? buildStatus('pending', 0, total)),
+                            ...buildStatus('retrying', prev[id]?.progress ?? 0, total, error.message, {
+                                attempt: meta.attempt,
+                                maxRetries: meta.maxRetries,
+                            }),
+                        },
+                    }));
+                    log(`Retrying: ${fileName} (${meta.attempt}/${meta.maxRetries}) - ${error.message}`);
+                },
+                onError: (error, fileName, meta) => {
+                    const id = meta?.fileId;
+                    if (id) {
+                        const total = fileById.get(id)?.size ?? 0;
+                        setStatusById((prev) => ({
+                            ...prev,
+                            [id]: {
+                                ...(prev[id] ?? buildStatus('pending', 0, total)),
+                                ...buildStatus('failed', prev[id]?.progress ?? 0, total, error.message),
+                            },
+                        }));
+                    }
+                    log(`Failed after retries: ${fileName} (${error.message})`);
+                },
+                onComplete: (fileName, url, meta) => {
+                    const id = meta?.fileId;
+                    if (id) {
+                        const total = fileById.get(id)?.size ?? 0;
+                        setStatusById((prev) => ({
+                            ...prev,
+                            [id]: {
+                                ...(prev[id] ?? buildStatus('pending', 0, total)),
+                                ...buildStatus('uploaded', 100, total),
+                            },
+                        }));
+                    }
+                    log(`Uploaded: ${fileName} -> ${url}`);
+                },
+            });
+        }
+        finally {
+            setIsUploading(false);
+            await refresh();
+        }
+    }, [client, config.adapterName, config.defaultUploadOptions, refresh, log]);
+    return {
+        client,
+        files,
+        statusById,
+        logs,
+        isUploading,
+        refresh,
+        addFiles,
+        clearFiles,
+        uploadAll,
+        uploadSelected,
+        pause,
+        resume,
+        cancel,
+        setRules,
+    };
+}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "uploader-sdk",
+  "version": "1.0.0",
+  "description": "Browser upload SDK with IndexedDB queue, parallel uploads, retries, pause/resume, and adapter-based storage integration.",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react-hooks.d.ts",
+      "import": "./dist/react-hooks.js",
+      "default": "./dist/react-hooks.js"
+    },
+    "./adapters/presigned-s3": {
+      "types": "./dist/presigned-s3-adapter.d.ts",
+      "import": "./dist/presigned-s3-adapter.js",
+      "default": "./dist/presigned-s3-adapter.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc",
+    "prepack": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ci": "npm run build && npm run test",
+    "test:live": "npm run build && node scripts/live-integration.mjs",
+    "release:check": "npm run test:ci && npm pack --dry-run",
+    "dev:backend": "node backend/server.js",
+    "dev:frontend": "vite --config app/vite.config.js",
+    "dev": "concurrently \"npm run dev:backend\" \"npm run dev:frontend\""
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "devDependencies": {
+    "@aws-sdk/client-s3": "^3.888.0",
+    "@aws-sdk/s3-request-presigner": "^3.888.0",
+    "@types/react": "^19.2.2",
+    "@types/react-dom": "^19.2.2",
+    "@types/node": "^25.5.0",
+    "concurrently": "^9.2.1",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
+    "express": "^5.1.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "fake-indexeddb": "^6.2.2",
+    "happy-dom": "^18.0.1",
+    "vitest": "^3.2.4",
+    "vite": "^7.1.7",
+    "typescript": "^5.9.3"
+  },
+  "keywords": [
+    "upload",
+    "sdk",
+    "indexeddb",
+    "multipart",
+    "presigned-url",
+    "react"
+  ]
+}