@zjlab-fe/data-hub-ui 0.21.7 → 0.23.0

package/es/components/file-uploader/hooks/use-upload.js

@@ -0,0 +1,327 @@
+import { __awaiter } from 'tslib';
+import { useUploadContext } from '../context/upload-context.js';
+import { useCallback, useRef, useMemo, useEffect } from 'react';
+import { UploadStatus } from '../constants.js';
+import { handlerRegistry } from '../context/handler-registry.js';
+import { actionRegistry } from '../context/action-registry.js';
+import { calculateChunkSize, createChunks, generateUploadId } from '../utils/chunk-handlers.js';
+import { getMissingHandlers } from '../utils/validate-handlers.js';
+import { useUploadEngine } from '../context/use-upload-engine.js';
+
+/**
+ * Main consumer hook for file uploads - Core functionality.
+ *
+ * This hook provides essential upload API with:
+ * - `files` - All files in the upload queue
+ * - `start`, `pause`, `resume`, `cancel` - Single file controls
+ * - `addFiles`, `removeFile` - File operations
+ *
+ * Use this hook for the most common upload scenarios.
+ * For extended functionality (batch operations, file selectors), use `useUploadExtend`.
+ *
+ * Global config (chunk sizes, concurrency) comes from UploadProvider.
+ * Handlers are provided per-file at selection time via addFiles options,
+ * allowing runtime-dependent targets (e.g., different folders/datasets).
+ *
+ * @example
+ * ```tsx
+ * function MyUploader({ datasetId }: { datasetId: string }) {
+ *   const { files, addFiles, start, pause } = useUpload();
+ *
+ *   return (
+ *     <>
+ *       <input
+ *         type="file"
+ *         onChange={(e) =>
+ *           addFiles(e.target.files, {
+ *             getHandlers: (file) => ({
+ *               onGetUploadUrls: (fileName, partCount) =>
+ *                 api.getUploadUrls(datasetId, fileName, partCount),
+ *               onPartComplete: (fileName, uploadId, partNum) =>
+ *                 api.markPartComplete(datasetId, uploadId, partNum),
+ *               onFileComplete: (fileName, uploadId) =>
+ *                 api.completeUpload(datasetId, uploadId),
+ *             }),
+ *           })
+ *         }
+ *       />
+ *       <div>
+ *         {files.map(f => (
+ *           <div key={f.id}>
+ *             {f.fileName}
+ *             <button onClick={() => start(f.id)}>Start</button>
+ *           </div>
+ *         ))}
+ *       </div>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+function useUpload() {
+    const { state, dispatch, config } = useUploadContext();
+    const { startUpload, pauseUpload, resumeUpload, cancelUpload } = useUploadEngine();
+    // ─────────────────────────────────────────────────────────────────────────────
+    // FILE OPERATIONS
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Add files to the upload queue.
+     * Accepts FileWithPath array with relative path information.
+     *
+     * @param files - Array of FileWithPath objects containing file and relativePath
+     * @param addOptions - Upload handlers (required) and optional configuration
+     * @param runtime - Optional runtime context (e.g., datasetId, folderId)
+     */
+    const addFiles = useCallback((files, addOptions, runtime) => {
+        if (!files.length)
+            return;
+        const newFiles = files.map((fileWithPath) => {
+            var _a, _b;
+            const { file, relativePath } = fileWithPath;
+            const resolvedHandlers = (_b = (_a = addOptions.getHandlers) === null || _a === void 0 ? void 0 : _a.call(addOptions, file)) !== null && _b !== void 0 ? _b : addOptions.handlers;
+            if (!resolvedHandlers) {
+                throw new Error('addFiles requires handlers per file. Provide options.handlers or options.getHandlers.');
+            }
+            const missing = getMissingHandlers(resolvedHandlers);
+            if (missing.length > 0) {
+                throw new Error(`Missing required upload handlers: ${missing.join(', ')}.`);
+            }
+            const chunkSize = calculateChunkSize(file.size, config);
+            const chunks = createChunks(file.size, chunkSize);
+            const id = generateUploadId();
+            // Register per-file handlers immediately so uploads can continue across navigation
+            handlerRegistry.register(id, resolvedHandlers, 'addFiles');
+            return {
+                id,
+                file,
+                fileName: file.name,
+                fileSize: file.size,
+                lastModified: file.lastModified,
+                status: UploadStatus.PENDING,
+                progress: 0,
+                uploadId: '',
+                chunks,
+                chunkSize,
+                relativePath,
+                runtime,
+                createdAt: Date.now(),
+            };
+        });
+        dispatch({ type: 'ADD_FILES', files: newFiles });
+    }, [config, dispatch]);
+    /**
+     * Remove a file from the queue and notify server if needed.
+     *
+     * @param id - File ID to remove
+     */
+    const removeFile = useCallback((id) => __awaiter(this, void 0, void 0, function* () {
+        // Get file and handlers before removing from state
+        const file = state.files.find((f) => f.id === id);
+        if (!file)
+            return;
+        const handlers = handlerRegistry.get(id);
+        // Dispatch removal
+        dispatch({ type: 'REMOVE_FILE', id });
+        handlerRegistry.unregister(id);
+        // Call onDeleteFile handler safely (don't block on failure)
+        try {
+            if (handlers === null || handlers === void 0 ? void 0 : handlers.onDeleteFile) {
+                const ctx = actionRegistry.getContext();
+                const result = yield handlers.onDeleteFile(file, ctx);
+                if (result && !result.success) {
+                    console.warn(`Delete notification failed for ${file.fileName}:`, result.reason);
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`Delete notification error for ${file.fileName}:`, error);
+        }
+    }), [state.files, dispatch]);
+    // ─────────────────────────────────────────────────────────────────────────────
+    // SINGLE FILE CONTROLS
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Start uploading a pending file.
+     *
+     * @param id - File ID to start
+     */
+    const start = useCallback((id) => __awaiter(this, void 0, void 0, function* () {
+        const file = state.files.find((f) => f.id === id);
+        if (file && file.status === UploadStatus.PENDING) {
+            yield startUpload(file);
+        }
+    }), [state.files, startUpload]);
+    /**
+     * Pause an uploading file.
+     * Active chunk uploads will be aborted.
+     *
+     * @param id - File ID to pause
+     */
+    const pause = useCallback((id) => pauseUpload(id), [pauseUpload]);
+    /**
+     * Resume a paused file.
+     * Continues from where it left off.
+     *
+     * @param id - File ID to resume
+     */
+    const resume = useCallback((id) => __awaiter(this, void 0, void 0, function* () { return resumeUpload(id); }), [resumeUpload]);
+    /**
+     * Cancel a file upload.
+     * Aborts all active uploads and notifies server.
+     *
+     * @param id - File ID to cancel
+     */
+    const cancel = useCallback((id) => cancelUpload(id), [cancelUpload]);
+    // ─────────────────────────────────────────────────────────────────────────────
+    // MUTEX FLAGS - Prevent concurrent batch operations
+    // ─────────────────────────────────────────────────────────────────────────────
+    const isStartingAllRef = useRef(false);
+    const isResumingAllRef = useRef(false);
+    // ─────────────────────────────────────────────────────────────────────────────
+    // SELECTORS
+    // ─────────────────────────────────────────────────────────────────────────────
+    const getFileById = useCallback((id) => state.files.find((f) => f.id === id), [state.files]);
+    const pendingFiles = useMemo(() => state.files.filter((f) => f.status === UploadStatus.PENDING), [state.files]);
+    const uploadingFiles = useMemo(() => state.files.filter((f) => f.status === UploadStatus.UPLOADING), [state.files]);
+    const successFiles = useMemo(() => state.files.filter((f) => f.status === UploadStatus.SUCCESS), [state.files]);
+    const failedFiles = useMemo(() => state.files.filter((f) => f.status === UploadStatus.FAILED), [state.files]);
+    const pausedFiles = useMemo(() => state.files.filter((f) => f.status === UploadStatus.PAUSED), [state.files]);
+    // ─────────────────────────────────────────────────────────────────────────────
+    // BATCH OPERATIONS
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Start all pending files.
+     * Files will be uploaded according to concurrency settings.
+     * Safe to call multiple times - will skip if already running.
+     */
+    const startAll = useCallback(() => __awaiter(this, void 0, void 0, function* () {
+        // Prevent concurrent executions
+        if (isStartingAllRef.current) {
+            return;
+        }
+        isStartingAllRef.current = true;
+        try {
+            // Capture pending files at the moment of call to avoid issues with state changes
+            const pending = state.files.filter((f) => f.status === UploadStatus.PENDING);
+            for (const file of pending) {
+                yield start(file.id);
+            }
+        }
+        finally {
+            isStartingAllRef.current = false;
+        }
+    }), [state.files, start]);
+    /**
+     * Pause all currently uploading files.
+     */
+    const pauseAll = useCallback(() => {
+        state.files.filter((f) => f.status === UploadStatus.UPLOADING).forEach((f) => pause(f.id));
+    }, [state.files, pause]);
+    /**
+     * Resume all paused files.
+     * Safe to call multiple times - will skip if already running.
+     */
+    const resumeAll = useCallback(() => __awaiter(this, void 0, void 0, function* () {
+        // Prevent concurrent executions
+        if (isResumingAllRef.current) {
+            return;
+        }
+        isResumingAllRef.current = true;
+        try {
+            const paused = state.files.filter((f) => f.status === UploadStatus.PAUSED);
+            for (const file of paused) {
+                yield resume(file.id);
+            }
+        }
+        finally {
+            isResumingAllRef.current = false;
+        }
+    }), [state.files, resume]);
+    /**
+     * Cancel all uploads (pending, uploading, and paused).
+     */
+    const cancelAll = useCallback(() => {
+        const cancelableStatuses = [UploadStatus.PENDING, UploadStatus.UPLOADING, UploadStatus.PAUSED];
+        state.files
+            .filter((f) => cancelableStatuses.includes(f.status))
+            .forEach((f) => cancel(f.id));
+    }, [state.files, cancel]);
+    /**
+     * Remove all succeeded files from the queue.
+     */
+    const clearSucceeded = useCallback(() => __awaiter(this, void 0, void 0, function* () {
+        const succeededFiles = state.files.filter((f) => f.status === UploadStatus.SUCCESS);
+        for (const file of succeededFiles) {
+            yield removeFile(file.id);
+        }
+    }), [state.files, removeFile]);
+    /**
+     * Remove all files from the queue (regardless of status).
+     */
+    const clearAll = useCallback(() => __awaiter(this, void 0, void 0, function* () {
+        const allFiles = [...state.files];
+        for (const file of allFiles) {
+            yield removeFile(file.id);
+        }
+    }), [state.files, removeFile]);
+    // ─────────────────────────────────────────────────────────────────────────────
+    // ACTION REGISTRY - Provide fresh context to handlers
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Update action registry with fresh references on every render.
+     * This ensures handlers always receive current versions of functions/state,
+     * solving the stale closure problem.
+     */
+    useEffect(() => {
+        actionRegistry.update({
+            files: state.files,
+            removeFile,
+            start,
+            pause,
+            resume,
+            cancel,
+            getFileById,
+        });
+    });
+    // ─────────────────────────────────────────────────────────────────────────────
+    // PUBLIC API - Core functionality only
+    // ─────────────────────────────────────────────────────────────────────────────
+    return {
+        // File state (from useUploadFiles)
+        files: state.files,
+        // File operations (from useUploadOperations)
+        addFiles,
+        removeFile,
+        // Single file controls (from useUploadControl)
+        start,
+        pause,
+        resume,
+        cancel,
+        /** Get a specific file by ID */
+        getFileById,
+        /** Files waiting to be uploaded */
+        pendingFiles,
+        /** Files currently uploading */
+        uploadingFiles,
+        /** Successfully completed uploads */
+        successFiles,
+        /** Failed uploads */
+        failedFiles,
+        /** Paused uploads */
+        pausedFiles,
+        /** Start all pending files */
+        startAll,
+        /** Pause all uploading files */
+        pauseAll,
+        /** Resume all paused files */
+        resumeAll,
+        /** Cancel all uploads */
+        cancelAll,
+        /** Clear all succeeded files */
+        clearSucceeded,
+        /** Clear all files */
+        clearAll,
+    };
+}
+
+export { useUpload };

package/es/components/file-uploader/utils/chunk-handlers.js

@@ -0,0 +1,66 @@
+import { DEFAULT_CHUNK_SIZE, ChunkStatus } from '../constants.js';
+
+/**
+ * Calculate optimal chunk size based on file size and config constraints
+ */
+function calculateChunkSize(fileSize, config) {
+    const { minChunkSize, maxChunkSize } = config;
+    // Start with default chunk size
+    let chunkSize = DEFAULT_CHUNK_SIZE;
+    // For very large files, increase chunk size to reduce chunk count
+    // Target max ~1000 chunks per file
+    const maxChunks = 1000;
+    const minChunkSizeForFile = Math.ceil(fileSize / maxChunks);
+    if (minChunkSizeForFile > chunkSize) {
+        chunkSize = minChunkSizeForFile;
+    }
+    // Clamp to config constraints
+    chunkSize = Math.max(minChunkSize, Math.min(maxChunkSize, chunkSize));
+    return chunkSize;
+}
+/**
+ * Calculate total number of chunks for a file
+ */
+function calculateTotalChunks(fileSize, chunkSize) {
+    if (fileSize === 0)
+        return 1; // Empty file still needs 1 chunk
+    return Math.ceil(fileSize / chunkSize);
+}
+/**
+ * Create initial chunk states for a file
+ * @param fileSize - Total file size in bytes
+ * @param chunkSize - Size of each chunk in bytes
+ * @returns Array of ChunkState objects with status and progress, partNum will be assigned later based on server response
+ */
+function createChunks(fileSize, chunkSize) {
+    const totalChunks = calculateTotalChunks(fileSize, chunkSize);
+    const chunks = [];
+    for (let i = 0; i < totalChunks; i++) {
+        chunks.push({
+            // partNum will be assigned after server provides upload URLs
+            status: ChunkStatus.PENDING,
+            progress: 0,
+        });
+    }
+    return chunks;
+}
+/**
+ * Extract a specific chunk blob from file
+ * @param file - The File object
+ * @param partNum - 0-indexed part number
+ * @param chunkSize - Size of each chunk in bytes
+ * @returns Blob containing the chunk data
+ */
+function getChunkBlob(file, partNum, chunkSize) {
+    const start = partNum * chunkSize;
+    const end = Math.min(start + chunkSize, file.size);
+    return file.slice(start, end);
+}
+/**
+ * Generate unique upload file ID
+ */
+function generateUploadId() {
+    return `upload-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+
+export { calculateChunkSize, calculateTotalChunks, createChunks, generateUploadId, getChunkBlob };

package/es/components/file-uploader/utils/ensure-handlers.js

@@ -0,0 +1,53 @@
+import { UploadStatus } from '../constants.js';
+import { createUploadError, UPLOAD_ERROR_CODE } from './error-handler.js';
+import { handlerRegistry } from '../context/handler-registry.js';
+import { getHandlerContext } from '../engine/queue-callbacks.js';
+
+/**
+ * Pure helper to fetch and validate handlers for a file.
+ * Returns null and dispatches failure if required handlers are missing.
+ */
+function ensureHandlers(uploadFile, dispatch) {
+    var _a;
+    const handlers = handlerRegistry.get(uploadFile.id);
+    if (!handlers) {
+        const error = createUploadError(UPLOAD_ERROR_CODE.MISSING_HANDLER, 'Upload handlers not registered for file ' +
+            uploadFile.id +
+            '. Provide handlers via addFiles(options).');
+        dispatch({
+            type: 'UPDATE_FILE',
+            id: uploadFile.id,
+            updates: {
+                status: UploadStatus.FAILED,
+                error: error.message,
+                errorCode: error.code,
+            },
+        });
+        return null;
+    }
+    const missing = [];
+    if (!handlers.onGetUploadUrls)
+        missing.push('onGetUploadUrls');
+    if (!handlers.onPartComplete)
+        missing.push('onPartComplete');
+    if (!handlers.onFileComplete)
+        missing.push('onFileComplete');
+    if (missing.length > 0) {
+        const error = createUploadError(UPLOAD_ERROR_CODE.MISSING_HANDLER, `Missing required handlers: ${missing.join(', ')}`);
+        dispatch({
+            type: 'UPDATE_FILE',
+            id: uploadFile.id,
+            updates: {
+                status: UploadStatus.FAILED,
+                error: error.message,
+                errorCode: error.code,
+            },
+        });
+        const ctx = getHandlerContext();
+        (_a = handlers.onError) === null || _a === void 0 ? void 0 : _a.call(handlers, uploadFile, new Error(error.message), ctx);
+        return null;
+    }
+    return handlers;
+}
+
+export { ensureHandlers };

package/es/components/file-uploader/utils/error-handler.js

@@ -0,0 +1,84 @@
+/**
+ * Standard error codes for upload operations.
+ * Allows consumers to handle specific error scenarios.
+ *
+ * Using const object instead of enum for compatibility with --erasableSyntaxOnly
+ * (TypeScript 5.8+) and better tree-shaking.
+ */
+const UPLOAD_ERROR_CODE = {
+    // Network errors
+    NETWORK_ERROR: 'NETWORK_ERROR',
+    TIMEOUT: 'TIMEOUT',
+    ABORT: 'ABORT',
+    // Server errors
+    URL_REQUEST_FAILED: 'URL_REQUEST_FAILED',
+    CHUNK_UPLOAD_FAILED: 'CHUNK_UPLOAD_FAILED',
+    MERGE_FAILED: 'MERGE_FAILED',
+    SERVER_ERROR: 'SERVER_ERROR',
+    // Validation errors
+    FILE_TOO_LARGE: 'FILE_TOO_LARGE',
+    INVALID_FILE_TYPE: 'INVALID_FILE_TYPE',
+    FILE_VALIDATION_FAILED: 'FILE_VALIDATION_FAILED',
+    // State errors
+    MISSING_FILE: 'MISSING_FILE',
+    MISSING_HANDLER: 'MISSING_HANDLER',
+    INVALID_STATE: 'INVALID_STATE',
+    // Generic
+    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+};
+/**
+ * Create a structured upload error.
+ */
+function createUploadError(code, message, originalError, context) {
+    return {
+        code,
+        message,
+        originalError,
+        context,
+    };
+}
+/**
+ * Parse an unknown error into a structured UploadError.
+ * Attempts to extract meaningful information from various error types.
+ */
+function parseError(error, defaultMessage = 'An error occurred') {
+    // Already an UploadError
+    if (isUploadError(error)) {
+        return error;
+    }
+    // Standard Error object
+    if (error instanceof Error) {
+        // Network errors
+        if (error.name === 'NetworkError' || error.message.includes('network')) {
+            return createUploadError(UPLOAD_ERROR_CODE.NETWORK_ERROR, 'Network connection failed', error);
+        }
+        // Timeout errors
+        if (error.name === 'TimeoutError' || error.message.includes('timeout')) {
+            return createUploadError(UPLOAD_ERROR_CODE.TIMEOUT, 'Request timed out', error);
+        }
+        // Abort errors
+        if (error.name === 'AbortError' || error.message.includes('abort')) {
+            return createUploadError(UPLOAD_ERROR_CODE.ABORT, 'Upload was cancelled', error);
+        }
+        // Generic error
+        return createUploadError(UPLOAD_ERROR_CODE.UNKNOWN_ERROR, error.message, error);
+    }
+    // String error
+    if (typeof error === 'string') {
+        return createUploadError(UPLOAD_ERROR_CODE.UNKNOWN_ERROR, error);
+    }
+    // Unknown error type
+    return createUploadError(UPLOAD_ERROR_CODE.UNKNOWN_ERROR, defaultMessage);
+}
+/**
+ * Type guard to check if an error is an UploadError.
+ */
+function isUploadError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        'message' in error &&
+        typeof error.code === 'string');
+}
+
+export { UPLOAD_ERROR_CODE, createUploadError, isUploadError, parseError };

package/es/components/file-uploader/utils/upload-controllers.js

@@ -0,0 +1,43 @@
+import { ChunkStatus } from '../constants.js';
+
+/**
+ * Get chunks that need to be uploaded after a resume.
+ * Returns pending and failed chunks (excludes completed).
+ */
+function getChunksForResume(file) {
+    const pendingPartNums = [];
+    let completedCount = 0;
+    for (const chunk of file.chunks) {
+        if (chunk.status === ChunkStatus.COMPLETED) {
+            completedCount++;
+        }
+        else {
+            // PENDING, FAILED, or UPLOADING (interrupted) - all need upload
+            // Only include if partNum is assigned (after URLs fetched)
+            if (chunk.partNum !== undefined) {
+                pendingPartNums.push(chunk.partNum);
+            }
+        }
+    }
+    return {
+        pendingPartNums,
+        pendingCount: pendingPartNums.length,
+        completedCount,
+    };
+}
+/**
+ * Reset interrupted chunks to pending state.
+ * Called when pausing - any uploading chunks should be marked pending.
+ * Returns updated chunks array.
+ */
+function resetInterruptedChunks(chunks) {
+    return chunks.map((chunk) => {
+        // Uploading chunks were interrupted by pause - reset to pending
+        if (chunk.status === ChunkStatus.UPLOADING) {
+            return Object.assign(Object.assign({}, chunk), { status: ChunkStatus.PENDING, progress: 0 });
+        }
+        return chunk;
+    });
+}
+
+export { getChunksForResume, resetInterruptedChunks };

package/es/components/file-uploader/utils/upload-handler.js

@@ -0,0 +1,68 @@
+import { __awaiter } from 'tslib';
+import axios from 'axios';
+
+const DEFAULT_TIMEOUT = 30 * 60 * 1000; // 30 minutes
+const DEFAULT_MAX_RETRIES = 3;
+const BASE_RETRY_DELAY = 1000;
+const uploadAxios = axios.create();
+/** Upload a chunk with automatic retry and exponential backoff */
+function uploadChunkWithRetry(chunk, uploadUrl, partNum, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const { signal, maxRetries = DEFAULT_MAX_RETRIES, requestConfig } = options || {};
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                return { success: false, partNum, error: new Error('Upload cancelled') };
+            }
+            const result = yield uploadChunk(chunk, uploadUrl, partNum, { signal, requestConfig });
+            if (result.success)
+                return result;
+            lastError = result.error;
+            if (((_a = result.error) === null || _a === void 0 ? void 0 : _a.message) === 'Upload cancelled')
+                return result;
+            // Exponential backoff before retry
+            if (attempt < maxRetries) {
+                yield sleep(BASE_RETRY_DELAY * Math.pow(2, attempt), signal);
+            }
+        }
+        return { success: false, partNum, error: lastError };
+    });
+}
+/** Upload a single chunk to the provided URL */
+function uploadChunk(chunk, uploadUrl, partNum, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const { signal, requestConfig = {} } = options || {};
+        try {
+            const axiosConfig = {
+                timeout: (_a = requestConfig.timeout) !== null && _a !== void 0 ? _a : DEFAULT_TIMEOUT,
+                withCredentials: (_b = requestConfig.withCredentials) !== null && _b !== void 0 ? _b : false,
+                headers: Object.assign({ 'Content-Type': 'application/octet-stream' }, requestConfig.headers),
+                signal,
+            };
+            yield uploadAxios.put(uploadUrl, chunk, axiosConfig);
+            return { success: true, partNum };
+        }
+        catch (error) {
+            if (axios.isCancel(error)) {
+                return { success: false, partNum, error: new Error('Upload cancelled') };
+            }
+            return { success: false, partNum, error: error };
+        }
+    });
+}
+/** Sleep helper that respects abort signal */
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+            return resolve();
+        const timeout = setTimeout(resolve, ms);
+        signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', () => {
+            clearTimeout(timeout);
+            resolve();
+        });
+    });
+}
+
+export { uploadChunkWithRetry };

package/es/components/file-uploader/utils/validate-handlers.js

@@ -0,0 +1,16 @@
+/**
+ * Get list of missing required handler names.
+ * Returns empty array if all required handlers are present.
+ */
+function getMissingHandlers(handlers) {
+    const missing = [];
+    if (!handlers.onGetUploadUrls)
+        missing.push('onGetUploadUrls');
+    if (!handlers.onPartComplete)
+        missing.push('onPartComplete');
+    if (!handlers.onFileComplete)
+        missing.push('onFileComplete');
+    return missing;
+}
+
+export { getMissingHandlers };