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

package/es/components/file-uploader/engine/queue-callbacks.js

@@ -0,0 +1,257 @@
+import { __awaiter } from 'tslib';
+import { UploadStatus, ChunkStatus } from '../constants.js';
+import { createUploadError, UPLOAD_ERROR_CODE, parseError } from '../utils/error-handler.js';
+import { handlerRegistry } from '../context/handler-registry.js';
+import { actionRegistry } from '../context/action-registry.js';
+import { fileStateStore } from '../context/file-state-store.js';
+
+/**
+ * Creates QueueManager callbacks that integrate with React state.
+ *
+ * These callbacks are called by QueueManager during upload lifecycle:
+ * - onChunkProgress: When chunk upload progress updates
+ * - onChunkComplete: When a chunk finishes uploading
+ * - onChunkError: When a chunk upload fails
+ * - onFileComplete: When all chunks of a file are uploaded
+ */
+function createQueueCallbacks({ dispatch }) {
+    return {
+        /**
+         * Called when chunk S3 upload completes successfully.
+         * Marks chunk as 90% complete and updates file progress.
+         */
+        onChunkUploadComplete: (fileId, partNum) => {
+            var _a;
+            // Mark chunk as 90% complete (S3 upload done, waiting for backend validation)
+            dispatch({
+                type: 'UPDATE_CHUNK',
+                fileId,
+                partNum,
+                updates: { progress: 90 },
+            });
+            // Calculate and update overall file progress (scaled to 90% max)
+            const file = fileStateStore.getFile(fileId);
+            if (!file)
+                return;
+            const totalProgress = file.chunks.reduce((sum, chunk) => {
+                // Use 90% for the chunk being updated, existing for others
+                const chunkProgress = chunk.partNum === partNum ? 90 : chunk.progress;
+                return sum + chunkProgress;
+            }, 0);
+            // Scale to 90% - remaining 10% is for final file merge
+            const fileProgress = Math.round((totalProgress / file.chunks.length) * 0.9);
+            dispatch({
+                type: 'UPDATE_FILE',
+                id: fileId,
+                updates: { progress: fileProgress },
+            });
+            // Notify handler of progress update
+            const handlers = getHandlersForFile(fileId);
+            const ctx = getHandlerContext();
+            (_a = handlers.onProgress) === null || _a === void 0 ? void 0 : _a.call(handlers, file, fileProgress, ctx);
+        },
+        /**
+         * Called when a chunk upload completes successfully.
+         * Notifies the server and marks chunk as completed only if server confirms.
+         * Returns validation result to queue manager.
+         */
+        onChunkComplete: (fileId, partNum) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const file = fileStateStore.getFile(fileId);
+            if (!file)
+                return { success: false, reason: 'File not found' };
+            const handlers = getHandlersForFile(fileId);
+            try {
+                // Notify server that part is complete and wait for confirmation
+                const result = yield ((_a = handlers.onPartComplete) === null || _a === void 0 ? void 0 : _a.call(handlers, file.fileName, file.uploadId, partNum, file));
+                if (result === null || result === void 0 ? void 0 : result.success) {
+                    // Server confirmed - mark chunk as completed (100%)
+                    dispatch({
+                        type: 'UPDATE_CHUNK',
+                        fileId,
+                        partNum,
+                        updates: {
+                            status: ChunkStatus.COMPLETED,
+                            progress: 100,
+                        },
+                    });
+                    // Update file progress after chunk completion (scaled to 90% max)
+                    const updatedFile = fileStateStore.getFile(fileId);
+                    if (updatedFile) {
+                        const totalProgress = updatedFile.chunks.reduce((sum, chunk) => {
+                            return sum + (chunk.partNum === partNum ? 100 : chunk.progress);
+                        }, 0);
+                        // Scale to 90% - remaining 10% is for final file merge
+                        const fileProgress = Math.round((totalProgress / updatedFile.chunks.length) * 0.9);
+                        dispatch({
+                            type: 'UPDATE_FILE',
+                            id: fileId,
+                            updates: { progress: fileProgress },
+                        });
+                        const ctx = getHandlerContext();
+                        (_b = handlers.onProgress) === null || _b === void 0 ? void 0 : _b.call(handlers, updatedFile, fileProgress, ctx);
+                    }
+                    return { success: true };
+                }
+                else {
+                    // Server rejected - mark chunk as failed
+                    const error = createUploadError(UPLOAD_ERROR_CODE.CHUNK_UPLOAD_FAILED, (_c = result === null || result === void 0 ? void 0 : result.reason) !== null && _c !== void 0 ? _c : 'Server rejected chunk completion');
+                    dispatch({
+                        type: 'UPDATE_CHUNK',
+                        fileId,
+                        partNum,
+                        updates: {
+                            status: ChunkStatus.FAILED,
+                            error: error.message,
+                        },
+                    });
+                    return { success: false, reason: error.message };
+                }
+            }
+            catch (error) {
+                // Network error or other exception during API call
+                const uploadError = parseError(error, 'Failed to notify server of chunk completion');
+                dispatch({
+                    type: 'UPDATE_CHUNK',
+                    fileId,
+                    partNum,
+                    updates: {
+                        status: ChunkStatus.FAILED,
+                        error: uploadError.message,
+                    },
+                });
+                return { success: false, reason: uploadError.message };
+            }
+        }),
+        /**
+         * Called when a chunk upload fails.
+         * Marks chunk as failed with error message.
+         */
+        onChunkError: (fileId, partNum, error) => {
+            const uploadError = parseError(error, 'Chunk upload failed');
+            dispatch({
+                type: 'UPDATE_CHUNK',
+                fileId,
+                partNum,
+                updates: {
+                    status: ChunkStatus.FAILED,
+                    error: uploadError.message,
+                },
+            });
+        },
+        /**
+         * Called when all chunks have been attempted (completed === total).
+         * Handles file completion based on whether all chunks succeeded.
+         */
+        onFileComplete: (fileId, result) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g;
+            const file = fileStateStore.getFile(fileId);
+            if (!file)
+                return;
+            const handlers = getHandlersForFile(fileId);
+            // If not all chunks succeeded, mark file as failed
+            if (!result.allSucceeded) {
+                const error = createUploadError(UPLOAD_ERROR_CODE.CHUNK_UPLOAD_FAILED, `Upload incomplete: ${result.succeeded}/${result.total} chunks succeeded`);
+                dispatch({
+                    type: 'UPDATE_FILE',
+                    id: fileId,
+                    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, file, new Error(error.message), ctx);
+                return;
+            }
+            // All chunks succeeded - set status to merging while server combines chunks
+            dispatch({
+                type: 'UPDATE_FILE',
+                id: fileId,
+                updates: { status: UploadStatus.MERGING },
+            });
+            try {
+                // Call server to merge chunks
+                const mergeResult = yield ((_b = handlers.onFileComplete) === null || _b === void 0 ? void 0 : _b.call(handlers, file.fileName, file.uploadId, file));
+                if (mergeResult === null || mergeResult === void 0 ? void 0 : mergeResult.success) {
+                    // Success - mark file as completed
+                    dispatch({
+                        type: 'UPDATE_FILE',
+                        id: fileId,
+                        updates: {
+                            status: UploadStatus.SUCCESS,
+                            progress: 100,
+                        },
+                    });
+                    // Call success callback if provided
+                    const ctx = getHandlerContext();
+                    (_c = handlers === null || handlers === void 0 ? void 0 : handlers.onUploadSuccess) === null || _c === void 0 ? void 0 : _c.call(handlers, file, ctx);
+                }
+                else {
+                    // Merge failed - mark file as failed
+                    const error = createUploadError(UPLOAD_ERROR_CODE.MERGE_FAILED, (_d = mergeResult === null || mergeResult === void 0 ? void 0 : mergeResult.reason) !== null && _d !== void 0 ? _d : 'Failed to finalize upload');
+                    dispatch({
+                        type: 'UPDATE_FILE',
+                        id: fileId,
+                        updates: {
+                            status: UploadStatus.FAILED,
+                            error: error.message,
+                            errorCode: error.code,
+                        },
+                    });
+                    const ctx = getHandlerContext();
+                    (_e = handlers.onError) === null || _e === void 0 ? void 0 : _e.call(handlers, file, new Error(error.message), ctx);
+                }
+            }
+            catch (error) {
+                // Unexpected error during merge
+                const uploadError = parseError(error, 'Merge operation failed');
+                dispatch({
+                    type: 'UPDATE_FILE',
+                    id: fileId,
+                    updates: {
+                        status: UploadStatus.FAILED,
+                        error: uploadError.message,
+                        errorCode: uploadError.code,
+                    },
+                });
+                const ctx = getHandlerContext();
+                (_f = handlers.onError) === null || _f === void 0 ? void 0 : _f.call(handlers, file, (_g = uploadError.originalError) !== null && _g !== void 0 ? _g : new Error(uploadError.message), ctx);
+            }
+        }),
+    };
+}
+/**
+ * Get handlers for a specific file from the global registry.
+ * Handlers must be registered before upload starts.
+ *
+ * @throws Error if handlers not found (indicates a programming error)
+ */
+function getHandlersForFile(fileId) {
+    const registeredHandlers = handlerRegistry.get(fileId);
+    if (!registeredHandlers) {
+        throw new Error('Handlers not found for file ' +
+            fileId +
+            '. ' +
+            'Ensure handlerRegistry.register() is called before upload starts.');
+    }
+    return registeredHandlers;
+}
+/**
+ * Get fresh handler context from the action registry.
+ * This provides always-current references to files and upload utilities,
+ * solving the stale closure problem in handler callbacks.
+ *
+ * @returns HandlerContext with fresh references
+ * @throws Error if context not available (useUpload hook not mounted)
+ */
+function getHandlerContext() {
+    const ctx = actionRegistry.getContext();
+    if (!ctx) {
+        throw new Error('Handler context not available. ' + 'Ensure useUpload hook is mounted before uploads start.');
+    }
+    return ctx;
+}
+
+export { createQueueCallbacks, getHandlerContext };

package/es/components/file-uploader/engine/queue-manager.js

@@ -0,0 +1,195 @@
+import { __awaiter } from 'tslib';
+import { ChunkStatus } from '../constants.js';
+import { uploadQueueItem } from './queue-uploader.js';
+
+/**
+ * Manages upload queue with configurable concurrency.
+ *
+ * Handles scheduling of chunk uploads across multiple files,
+ * respecting concurrency limits for both files and chunks per file.
+ */
+class QueueManager {
+    constructor(config, callbacks) {
+        /** Pending items waiting to be uploaded */
+        this.queue = [];
+        /** Currently uploading items, grouped by file ID */
+        this.activeByFile = new Map();
+        /** Set of file IDs that are paused */
+        this.pausedFiles = new Set();
+        /** Track chunk completion counts per file */
+        this.fileChunkCounts = new Map();
+        this.config = config;
+        this.callbacks = callbacks;
+    }
+    /**
+     * Add a file's chunks to the upload queue.
+     * Only pending chunks are added; completed chunks are skipped.
+     */
+    addFile(uploadFile) {
+        if (!uploadFile.file)
+            return;
+        const pendingChunks = uploadFile.chunks.filter((c) => c.status === ChunkStatus.PENDING);
+        const completedCount = uploadFile.chunks.filter((c) => c.status === ChunkStatus.COMPLETED).length;
+        this.fileChunkCounts.set(uploadFile.id, {
+            total: uploadFile.chunks.length,
+            completed: completedCount,
+            succeeded: completedCount,
+        });
+        for (const chunk of pendingChunks) {
+            if (!chunk.uploadUrl)
+                continue;
+            this.queue.push({
+                fileId: uploadFile.id,
+                file: uploadFile.file,
+                chunk,
+                uploadUrl: chunk.uploadUrl,
+                chunkSize: uploadFile.chunkSize,
+                abortController: new AbortController(),
+            });
+        }
+        this.processQueue();
+    }
+    /**
+     * Process queue and start uploads respecting concurrency limits.
+     * - Max `concurrentFiles` files can upload simultaneously
+     * - Each file can have max `concurrentChunks` chunks uploading
+     */
+    processQueue() {
+        const fileIds = new Set(this.queue.map((q) => q.fileId));
+        for (const fileId of fileIds) {
+            // Skip paused files
+            if (this.pausedFiles.has(fileId))
+                continue;
+            // Check if we can start a new file (respect concurrentFiles limit)
+            if (!this.activeByFile.has(fileId) && this.activeByFile.size >= this.config.concurrentFiles) {
+                continue;
+            }
+            // Calculate available slots for this file
+            const fileActive = this.activeByFile.get(fileId) || [];
+            const slots = this.config.concurrentChunks - fileActive.length;
+            if (slots <= 0)
+                continue;
+            // Start uploads for available slots
+            const toStart = this.queue.filter((q) => q.fileId === fileId).slice(0, slots);
+            for (const item of toStart) {
+                this.startUpload(item);
+            }
+        }
+    }
+    /**
+     * Start uploading a single chunk.
+     * Handles progress, completion, and error callbacks.
+     */
+    startUpload(item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Move from queue to active
+            this.queue = this.queue.filter((q) => q !== item);
+            const fileActive = this.activeByFile.get(item.fileId) || [];
+            fileActive.push(item);
+            this.activeByFile.set(item.fileId, fileActive);
+            // Execute upload
+            const result = yield uploadQueueItem(item, this.config);
+            // Remove from active
+            this.removeFromActive(item);
+            // Handle result and track completion/success
+            const counts = this.fileChunkCounts.get(item.fileId);
+            if (!counts)
+                return;
+            if (result.success) {
+                // S3 upload succeeded - mark as 90% complete
+                this.callbacks.onChunkUploadComplete(item.fileId, item.chunk.partNum);
+                // Now validate with backend (will mark as 100% if successful)
+                const chunkResult = yield this.callbacks.onChunkComplete(item.fileId, item.chunk.partNum);
+                if (chunkResult.success) {
+                    // Backend validated successfully
+                    counts.succeeded++;
+                }
+                counts.completed++;
+            }
+            else if (result.error) {
+                // Upload failed
+                this.callbacks.onChunkError(item.fileId, item.chunk.partNum, result.error);
+                counts.completed++;
+            }
+            // Check if all chunks are done (completed === total)
+            if (counts.completed >= counts.total) {
+                yield this.callbacks.onFileComplete(item.fileId, {
+                    succeeded: counts.succeeded,
+                    total: counts.total,
+                    allSucceeded: counts.succeeded === counts.total,
+                });
+                this.fileChunkCounts.delete(item.fileId);
+            }
+            // Continue processing queue
+            this.processQueue();
+        });
+    }
+    /** Remove an item from the active uploads map */
+    removeFromActive(item) {
+        const active = this.activeByFile.get(item.fileId) || [];
+        const filtered = active.filter((a) => a !== item);
+        if (filtered.length === 0) {
+            this.activeByFile.delete(item.fileId);
+        }
+        else {
+            this.activeByFile.set(item.fileId, filtered);
+        }
+    }
+    /** Pause uploads for a file (aborts active uploads) */
+    pauseFile(fileId) {
+        this.pausedFiles.add(fileId);
+        this.abortFileUploads(fileId);
+    }
+    /** Resume uploads for a paused file */
+    resumeFile(fileId) {
+        this.pausedFiles.delete(fileId);
+        this.processQueue();
+    }
+    /** Cancel all uploads for a file and clean up */
+    cancelFile(fileId) {
+        this.abortFileUploads(fileId);
+        this.queue = this.queue.filter((q) => q.fileId !== fileId);
+        this.pausedFiles.delete(fileId);
+        this.fileChunkCounts.delete(fileId);
+    }
+    /** Abort all active uploads for a file */
+    abortFileUploads(fileId) {
+        const active = this.activeByFile.get(fileId) || [];
+        for (const item of active) {
+            item.abortController.abort();
+        }
+        this.activeByFile.delete(fileId);
+    }
+    /** Get count of active files and total active chunks */
+    getActiveCount() {
+        let chunks = 0;
+        for (const active of this.activeByFile.values()) {
+            chunks += active.length;
+        }
+        return { files: this.activeByFile.size, chunks };
+    }
+    /** Check if a file is currently paused */
+    isFilePaused(fileId) {
+        return this.pausedFiles.has(fileId);
+    }
+    /** Get number of items waiting in queue */
+    getQueueLength() {
+        return this.queue.length;
+    }
+    /** Get number of pending queue items for a specific file */
+    getFileQueueLength(fileId) {
+        return this.queue.filter((q) => q.fileId === fileId).length;
+    }
+    /** Check if file has any items in queue or active uploads */
+    hasFileInQueue(fileId) {
+        const inQueue = this.queue.some((q) => q.fileId === fileId);
+        const isActive = this.activeByFile.has(fileId);
+        return inQueue || isActive;
+    }
+    /** Clear all queue items for a file (used before re-adding on resume) */
+    clearFileFromQueue(fileId) {
+        this.queue = this.queue.filter((q) => q.fileId !== fileId);
+    }
+}
+
+export { QueueManager };

package/es/components/file-uploader/engine/queue-uploader.js

@@ -0,0 +1,25 @@
+import { __awaiter } from 'tslib';
+import { getChunkBlob } from '../utils/chunk-handlers.js';
+import { uploadChunkWithRetry } from '../utils/upload-handler.js';
+
+/** Upload a single queue item and return result */
+function uploadQueueItem(item, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const chunkBlob = getChunkBlob(item.file, item.chunk.partNum, item.chunkSize);
+        const result = yield uploadChunkWithRetry(chunkBlob, item.uploadUrl, item.chunk.partNum, {
+            signal: item.abortController.signal,
+            requestConfig: config.requestConfig,
+        });
+        if (result.success) {
+            return { item, success: true };
+        }
+        // Treat cancellation as non-error
+        if (((_a = result.error) === null || _a === void 0 ? void 0 : _a.message) === 'Upload cancelled') {
+            return { item, success: false };
+        }
+        return { item, success: false, error: result.error };
+    });
+}
+
+export { uploadQueueItem };