dpu-cloud-sdk 1.0.0

package/dist/DPUClient.js

@@ -0,0 +1,1043 @@
+import pLimit from "p-limit";
+import { CancelDownload, CompressFolder, GetStatusCompress, } from "./api/compress";
+import { ServiceIntegration } from "./ServiceIntegration";
+import { ApiStatus, ConfigFileRules } from "./utils/Constants";
+import { dpuConfig } from "./utils/Config";
+import { readFileDataAsBase64 } from "./utils/Helper";
+import { StatusWorker } from "./utils/Enum";
+// import streamSaver from "streamsaver";
+import { GetEPSGRegionCode, GetFileTileSet, GetStatusTranslate, GetStatusTranslateFile, TranslateFile, } from "./api/translate";
+import { GetToken } from "./api/auth";
+export class DPUClient {
+    accessToken;
+    reFreshToken;
+    maxRetry;
+    workersStatus = [];
+    constructor(accessToken, reFreshToken, maxRetry, baseURL) {
+        this.accessToken = accessToken;
+        this.reFreshToken = reFreshToken;
+        this.maxRetry = maxRetry || ConfigFileRules.MaxRetry;
+        // Set the base URL if provided
+        if (baseURL) {
+            dpuConfig.setBaseURL(baseURL);
+        }
+    }
+    async baseAction(action) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                if (this.accessToken) {
+                    let currentRetry = 0;
+                    let response;
+                    do {
+                        currentRetry++;
+                        response = await action(this.accessToken);
+                        if (response.statusCode === ApiStatus.Success)
+                            resolve(response.data);
+                        else if (response.statusCode === ApiStatus.Unauthorized &&
+                            this.reFreshToken) {
+                            this.accessToken = await this.reFreshToken();
+                        }
+                        else
+                            reject(response.message);
+                    } while (this.maxRetry > currentRetry &&
+                        response.statusCode === ApiStatus.Unauthorized);
+                }
+                else
+                    reject("Access token is required");
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    async baseActionAnonymous(action) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                let response;
+                response = await action();
+                if (response.statusCode === ApiStatus.Success)
+                    resolve(response.data);
+                else
+                    reject(response.message);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    //#region Compress and Download Folder
+    async compressFolder(bucketName, rootFolder) {
+        return await this.baseAction((accessToken) => {
+            return CompressFolder(accessToken, bucketName, rootFolder);
+        });
+    }
+    async getStatusCompress(requestIds) {
+        return await this.baseAction((accessToken) => {
+            return GetStatusCompress(requestIds, accessToken);
+        });
+    }
+    async cancelDownload(requestId) {
+        return await this.baseAction((accessToken) => {
+            return CancelDownload(requestId, accessToken);
+        });
+    }
+    //#endregion
+    //#region Upload File
+    async uploadFileAferInit(path, file, initUpload, cancellationToken, onProgress, maxWebWorker, worker, dataUploadId) {
+        const bucketName = path.split("/").at(0);
+        if (!bucketName)
+            return new Promise((resolve, reject) => {
+                reject("Path is not valid");
+            });
+        const customFileName = path.split("/").at(-1);
+        if (!customFileName)
+            return new Promise((resolve, reject) => {
+                reject("Path is not valid");
+            });
+        const prefix = path
+            .replace(bucketName + "/", "")
+            .replace(customFileName, "");
+        if (cancellationToken?.signal.aborted) {
+            return new Promise((resolve, reject) => {
+                reject("Upload cancelled");
+            });
+        }
+        const abortHandler = () => {
+            // Cleanup workers
+            this.workersStatus.forEach((workerStatus) => {
+                workerStatus.worker.terminate();
+            });
+            this.workersStatus = [];
+        };
+        cancellationToken?.signal.addEventListener("abort", abortHandler);
+        try {
+            const result = await this.uploadFileRetry(bucketName, file, cancellationToken || new AbortController(), onProgress, maxWebWorker, prefix, initUpload, customFileName, worker, dataUploadId);
+            // Cleanup
+            cancellationToken?.signal.removeEventListener("abort", abortHandler);
+            return result;
+        }
+        catch (error) {
+            // Cleanup
+            cancellationToken?.signal.removeEventListener("abort", abortHandler);
+            if (error instanceof Error && error.name === "AbortError") {
+                return new Promise((resolve, reject) => {
+                    reject({
+                        errorCode: "ClientAbort",
+                        message: "Upload cancelled",
+                    });
+                });
+            }
+            throw error;
+        }
+    }
+    async uploadFileRetry(bucketName, file, cancellationToken, onProgress, maxWebWorker, prefix, initUpload, customFileName, worker, dataUploadId) {
+        if (!this.accessToken)
+            return new Promise((resolve, reject) => {
+                reject("Access token is required");
+            });
+        // Check cancellation before starting
+        if (cancellationToken.signal.aborted) {
+            return new Promise((resolve, reject) => {
+                reject("Upload cancelled");
+            });
+        }
+        const fileSize = file.size;
+        const fileName = prefix && prefix.length > 0
+            ? `${prefix.at(prefix.length - 1) === "/" ? prefix : prefix + "/"}${customFileName ?? file.name}`
+            : customFileName ?? file.name;
+        maxWebWorker = maxWebWorker ? maxWebWorker : ConfigFileRules.MaxWebWorker;
+        var service = new ServiceIntegration();
+        await service.validateFileSize(fileName, fileSize);
+        // Handle small file upload
+        if (fileSize <= ConfigFileRules.ChunkSize) {
+            const buffer = await readFileDataAsBase64(file);
+            const resUploadSmallFile = await service.uploadSmallFile(bucketName, fileName, buffer, this.accessToken, cancellationToken, onProgress, undefined, true);
+            onProgress?.(buffer.length);
+            return resUploadSmallFile;
+        }
+        // Init multi upload
+        if (!initUpload) {
+            initUpload = await service.initMultiPartUpload(bucketName, fileName, this.accessToken, undefined, cancellationToken);
+            if (!initUpload) {
+                return new Promise((resolve, reject) => {
+                    reject(`Fail to initiate multipart upload for file ${fileName}`);
+                });
+            }
+        }
+        var numberOfChunks = service.calculateNumberOfChunks(fileSize);
+        const urls = await service.generatePresignedUrls(bucketName, fileName, initUpload, numberOfChunks, this.accessToken, cancellationToken);
+        if (!urls) {
+            return new Promise((resolve, reject) => {
+                reject(`Fail to generate presigned urls for file ${fileName}`);
+            });
+        }
+        const uploadChunks = async (chunkIndexs) => {
+            let chunkIndexErrors = [];
+            let responseUploadChilds = [];
+            const maxLimit = chunkIndexs.length < ConfigFileRules.LimitFile
+                ? chunkIndexs.length
+                : ConfigFileRules.LimitFile;
+            const limit = pLimit(maxLimit);
+            // init worker
+            const workerPorts = [];
+            const maxWorker = chunkIndexs.length < maxWebWorker ? chunkIndexs.length : maxWebWorker;
+            // Create workers
+            for (let index = 0; index < maxWorker; index++) {
+                const channel = new MessageChannel();
+                const worker = new Worker(new URL("workerUploadChildFile", import.meta.url));
+                worker.postMessage({ port: channel.port2 }, [channel.port2]);
+                workerPorts.push(channel.port1);
+                this.workersStatus.push({
+                    worker: worker,
+                    taskNumber: 0,
+                    id: index,
+                    taskHandle: 0,
+                });
+            }
+            if (worker) {
+                worker.postMessage({ workerPorts }, workerPorts);
+            }
+            try {
+                // const tasks = Array.from({ length: numberOfChunks }, (_, index) => {
+                const tasks = chunkIndexs.map((index) => {
+                    return limit(async () => {
+                        // Check cancellation before each chunk
+                        if (cancellationToken.signal.aborted) {
+                            throw new Error("Upload cancelled");
+                        }
+                        try {
+                            const chunkStart = index * ConfigFileRules.ChunkSize;
+                            const chunkEnd = Math.min(chunkStart + ConfigFileRules.ChunkSize, fileSize);
+                            const chunk = file.slice(chunkStart, chunkEnd);
+                            const arrayBuffer = await chunk.arrayBuffer();
+                            var url = urls[index];
+                            return this.runOnWorker({
+                                currentPresignUrl: { url: url, headers: initUpload.headers },
+                                arrayBuffer: arrayBuffer,
+                                partNumber: index + 1,
+                                onProgress: onProgress,
+                                requestId: `${index + 1}-${Date.now()}`,
+                                cancellationToken: cancellationToken,
+                                dataUploadId: dataUploadId,
+                                fileName: file.name,
+                            });
+                        }
+                        catch (error) {
+                            chunkIndexErrors.push(index);
+                        }
+                    });
+                });
+                const results = await Promise.allSettled(tasks);
+                for (let i = 0; i < results.length; i++) {
+                    if (results[i].status === "fulfilled") {
+                        const responseUploadChild = results[i].value.responseUpload;
+                        if (responseUploadChild) {
+                            responseUploadChilds.push(responseUploadChild);
+                        }
+                    }
+                }
+                return { chunkIndexErrors, responseUploadChilds };
+            }
+            catch (error) {
+                // Cleanup on error or cancellation
+                throw error;
+            }
+            finally {
+                // Always cleanup workers
+                this.workersStatus.forEach((workerStatus) => {
+                    workerStatus.worker.terminate();
+                });
+                this.workersStatus = [];
+            }
+        };
+        let currentRetry = 0;
+        const eTags = {};
+        let chunkIndexErrors = Array.from({ length: numberOfChunks }, (_, index) => index);
+        let responseUploadChilds = [];
+        do {
+            if (cancellationToken.signal.aborted) {
+                throw new Error("Upload cancelled");
+            }
+            const responseUploadChunks = await uploadChunks(chunkIndexErrors);
+            chunkIndexErrors = responseUploadChunks.chunkIndexErrors;
+            responseUploadChilds = responseUploadChilds.concat(responseUploadChunks.responseUploadChilds);
+            currentRetry++;
+        } while (currentRetry < ConfigFileRules.MaxRetry &&
+            chunkIndexErrors.length > 0);
+        if (chunkIndexErrors.length > 0) {
+            return new Promise((resolve, reject) => {
+                reject(`Fail to upload chunks ${chunkIndexErrors} for file ${fileName}`);
+            });
+        }
+        for (let i = 0; i < responseUploadChilds.length; i++) {
+            const responseUploadChild = responseUploadChilds[i];
+            Object.defineProperty(eTags, responseUploadChild.partNumber, {
+                value: responseUploadChild.eTag,
+                enumerable: true,
+            });
+        }
+        var completeResponse = await service.completeMultipartUpload(bucketName, fileName, initUpload.uploadId, eTags, this.accessToken, cancellationToken);
+        onProgress?.(fileSize);
+        if (!completeResponse) {
+            throw new Error(`Fail to complete multipart upload for file ${fileName}`);
+        }
+        const objectDetail = await service.getObjectDetail(bucketName, fileName, this.accessToken);
+        if (!objectDetail) {
+            throw new Error(`Fail to get object detail for file ${fileName}`);
+        }
+        return {
+            bucketName: bucketName,
+            fileName: fileName,
+            contentLength: fileSize,
+            versionFile: objectDetail.versionId,
+            dateVersionFile: objectDetail.lastModified,
+        };
+    }
+    async uploadFile(bucketName, file, cancellationToken, onProgress, maxWebWorker, prefix, initUpload, customFileName, worker, dataUploadId) {
+        if (!this.accessToken)
+            return new Promise((resolve, reject) => {
+                reject("Access token is required");
+            });
+        // Check cancellation before starting
+        if (cancellationToken.signal.aborted) {
+            return new Promise((resolve, reject) => {
+                reject("Upload cancelled");
+            });
+        }
+        const fileSize = file.size;
+        const fileName = prefix && prefix.length > 0
+            ? `${prefix.at(prefix.length - 1) === "/" ? prefix : prefix + "/"}${customFileName ?? file.name}`
+            : customFileName ?? file.name;
+        maxWebWorker = maxWebWorker ? maxWebWorker : ConfigFileRules.MaxWebWorker;
+        var service = new ServiceIntegration();
+        await service.validateFileSize(fileName, fileSize);
+        // Handle small file upload
+        if (fileSize <= ConfigFileRules.ChunkSize) {
+            const buffer = await readFileDataAsBase64(file);
+            const resUploadSmallFile = await service.uploadSmallFile(bucketName, fileName, buffer, this.accessToken, cancellationToken, onProgress, undefined, true);
+            onProgress?.(buffer.length);
+            return resUploadSmallFile;
+        }
+        // Init multi upload
+        if (!initUpload) {
+            initUpload = await service.initMultiPartUpload(bucketName, fileName, this.accessToken, undefined, cancellationToken);
+            if (!initUpload) {
+                return new Promise((resolve, reject) => {
+                    reject(`Fail to initiate multipart upload for file ${fileName}`);
+                });
+            }
+        }
+        var numberOfChunks = service.calculateNumberOfChunks(fileSize);
+        const urls = await service.generatePresignedUrls(bucketName, fileName, initUpload, numberOfChunks, this.accessToken, cancellationToken);
+        if (!urls) {
+            return new Promise((resolve, reject) => {
+                reject(`Fail to generate presigned urls for file ${fileName}`);
+            });
+        }
+        const eTags = {};
+        const maxLimit = numberOfChunks < ConfigFileRules.LimitFile
+            ? numberOfChunks
+            : ConfigFileRules.LimitFile;
+        const limit = pLimit(maxLimit);
+        // init worker
+        const workerPorts = [];
+        const maxWorker = numberOfChunks < maxWebWorker ? numberOfChunks : maxWebWorker;
+        // Create workers
+        for (let index = 0; index < maxWorker; index++) {
+            const channel = new MessageChannel();
+            const worker = new Worker(new URL("workerUploadChildFile", import.meta.url));
+            worker.postMessage({ port: channel.port2 }, [channel.port2]);
+            workerPorts.push(channel.port1);
+            this.workersStatus.push({
+                worker: worker,
+                taskNumber: 0,
+                id: index,
+                taskHandle: 0,
+            });
+        }
+        if (worker) {
+            worker.postMessage({ workerPorts }, workerPorts);
+        }
+        try {
+            const tasks = Array.from({ length: numberOfChunks }, (_, index) => {
+                return limit(async () => {
+                    // Check cancellation before each chunk
+                    if (cancellationToken.signal.aborted) {
+                        throw new Error("Upload cancelled");
+                    }
+                    const chunkStart = index * ConfigFileRules.ChunkSize;
+                    const chunkEnd = Math.min(chunkStart + ConfigFileRules.ChunkSize, fileSize);
+                    const chunk = file.slice(chunkStart, chunkEnd);
+                    const arrayBuffer = await chunk.arrayBuffer();
+                    var url = urls[index];
+                    return this.runOnWorker({
+                        currentPresignUrl: { url: url, headers: initUpload.headers },
+                        arrayBuffer: arrayBuffer,
+                        partNumber: index + 1,
+                        onProgress: onProgress,
+                        requestId: `${index + 1}-${Date.now()}`,
+                        cancellationToken: cancellationToken,
+                        dataUploadId: dataUploadId,
+                        fileName: file.name,
+                    });
+                });
+            });
+            const results = await Promise.all(tasks);
+            for (let i = 0; i < results.length; i++) {
+                const responseUploadChild = results[i].responseUpload;
+                if (!responseUploadChild) {
+                    throw new Error(`Fail to upload chunk ${i} of file ${fileName}`);
+                }
+                Object.defineProperty(eTags, responseUploadChild.partNumber, {
+                    value: responseUploadChild.eTag,
+                    enumerable: true,
+                });
+            }
+            var completeResponse = await service.completeMultipartUpload(bucketName, fileName, initUpload.uploadId, eTags, this.accessToken, cancellationToken);
+            onProgress?.(fileSize);
+            if (!completeResponse) {
+                throw new Error(`Fail to complete multipart upload for file ${fileName}`);
+            }
+            const objectDetail = await service.getObjectDetail(bucketName, fileName, this.accessToken);
+            if (!objectDetail) {
+                throw new Error(`Fail to get object detail for file ${fileName}`);
+            }
+            return {
+                bucketName: bucketName,
+                fileName: fileName,
+                contentLength: fileSize,
+                versionFile: objectDetail.versionId,
+                dateVersionFile: objectDetail.lastModified,
+            };
+        }
+        catch (error) {
+            // Cleanup on error or cancellation
+            throw error;
+        }
+        finally {
+            // Always cleanup workers
+            this.workersStatus.forEach((workerStatus) => {
+                workerStatus.worker.terminate();
+            });
+            this.workersStatus = [];
+        }
+    }
+    async runOnWorker(data) {
+        const workerStatus = this.workersStatus.find((x) => x.taskNumber < ConfigFileRules.TaskCurrently);
+        if (!workerStatus)
+            return Promise.reject("No worker available");
+        // increase task number
+        workerStatus.taskNumber++;
+        const worker = workerStatus.worker;
+        return new Promise((resolve, reject) => {
+            if (typeof Worker !== "undefined") {
+                worker.addEventListener("message", (message) => {
+                    if (message.data.requestId !== data.requestId)
+                        return;
+                    workerStatus.taskNumber--;
+                    if (message.data && message.data.status === StatusWorker.Success) {
+                        data.onProgress && data.onProgress(message.data.contentLength);
+                        resolve(message.data);
+                    }
+                    else {
+                        reject(message.data);
+                    }
+                });
+                worker.addEventListener("error", (error) => {
+                    workerStatus.taskNumber--;
+                    console.error(error);
+                    reject(error);
+                });
+                // Add abort handler to worker
+                const abortHandler = () => {
+                    worker.postMessage({
+                        type: "abort",
+                        requestId: data.requestId,
+                    });
+                };
+                data.cancellationToken?.signal.addEventListener("abort", abortHandler);
+                const newData = {
+                    currentPresignUrl: data.currentPresignUrl,
+                    arrayBuffer: data.arrayBuffer,
+                    partNumber: data.partNumber,
+                    requestId: data.requestId,
+                    dataUploadId: data.dataUploadId,
+                    fileName: data.fileName,
+                };
+                worker.postMessage(newData, [data.arrayBuffer]);
+                // Cleanup abort handler when promise resolves or rejects
+                return () => {
+                    data.cancellationToken?.signal.removeEventListener("abort", abortHandler);
+                };
+            }
+            else {
+                console.error("Web Workers are not supported in this environment.");
+                reject("Web Workers are not supported in this environment.");
+            }
+        });
+    }
+    //#endregion
+    //#region Upload folder
+    async uploadFolderAferInit(filesInitiated, cancellationToken, worker, dataUploadId, onProgress, maxWebWorker) {
+        const bucketName = filesInitiated[0].path.split("/").at(0);
+        if (!bucketName)
+            return new Promise((resolve, reject) => {
+                reject("Path is not valid");
+            });
+        if (cancellationToken?.signal.aborted) {
+            return new Promise((resolve, reject) => {
+                reject("Upload cancelled");
+            });
+        }
+        const abortHandler = () => {
+            // Cleanup workers
+            this.workersStatus.forEach((workerStatus) => {
+                workerStatus.worker.terminate();
+            });
+            this.workersStatus = [];
+        };
+        cancellationToken?.signal.addEventListener("abort", abortHandler);
+        try {
+            const result = await this.uploadFolder(bucketName, filesInitiated.map((x) => ({
+                file: x.file,
+                fileKey: x.fileKey,
+                customFileName: x.path.split("/").slice(1).join("/"),
+                initUpload: x.initUpload,
+                isGetInfo: x.isGetInfo,
+            })), cancellationToken || new AbortController(), worker, dataUploadId, onProgress, maxWebWorker);
+            // Cleanup
+            cancellationToken?.signal.removeEventListener("abort", abortHandler);
+            return result;
+        }
+        catch (error) {
+            // Cleanup
+            cancellationToken?.signal.removeEventListener("abort", abortHandler);
+            if (error instanceof Error && error.name === "AbortError") {
+                return new Promise((resolve, reject) => {
+                    reject({
+                        errorCode: "ClientAbort",
+                        message: "Upload cancelled",
+                    });
+                });
+            }
+            throw error;
+        }
+    }
+    async uploadFolder(bucketName, files, cancellationToken, worker, dataUploadId, onProgress, maxWebWorker, prefix) {
+        try {
+            if (!this.accessToken)
+                return new Promise((resolve, reject) => {
+                    reject("Access token is required");
+                });
+            // Check cancellation before starting
+            if (cancellationToken.signal.aborted) {
+                return new Promise((resolve, reject) => {
+                    reject({
+                        errorCode: "ClientAbort",
+                        message: "Upload cancelled",
+                    });
+                });
+            }
+            prefix =
+                prefix && prefix.length > 0
+                    ? `${prefix.at(prefix.length - 1) === "/" ? prefix : prefix + "/"}`
+                    : "";
+            maxWebWorker = maxWebWorker ? maxWebWorker : ConfigFileRules.MaxWebWorker;
+            let percentOneBuffer = 100 / files.length;
+            let currentPercent = 0;
+            let currentRetry = 0;
+            const percentOfChild = ({ fileKey, versionFile, }) => {
+                currentPercent += percentOneBuffer;
+                onProgress?.({
+                    percentCompleted: Math.floor(currentPercent),
+                    fileKey: fileKey,
+                    versionFile: versionFile,
+                });
+            };
+            let filesUploadFail = files;
+            let filesUploadSuccess = [];
+            do {
+                // Check cancellation before each retry
+                if (cancellationToken.signal.aborted) {
+                    throw new Error("Upload cancelled");
+                }
+                const resUpload = await this.uploadMultiFileRetry(bucketName, filesUploadFail, this.accessToken, cancellationToken, maxWebWorker, this.reFreshToken, percentOfChild, prefix, worker, dataUploadId);
+                currentRetry++;
+                if (resUpload) {
+                    filesUploadFail = resUpload.filesUploadFail ?? [];
+                    filesUploadSuccess = filesUploadSuccess.concat(resUpload.filesUploadSuccess ?? []);
+                }
+                else {
+                    return new Promise((resolve, reject) => {
+                        reject("Fail to upload files");
+                    });
+                }
+            } while (currentRetry < ConfigFileRules.MaxRetry &&
+                filesUploadFail &&
+                filesUploadFail.length > 0);
+            // get list file upload fail
+            if (!filesUploadFail)
+                return new Promise((resolve, reject) => {
+                    reject("Fail to upload files");
+                });
+            const filesNameUploadFail = filesUploadFail.map((file) => {
+                return file.customFileName ?? file.file.webkitRelativePath;
+            });
+            // if(worker) {
+            //   worker.postMessage({
+            //     type: "progressUpload",
+            //     progress: {
+            //       dataUploadId: dataUploadId,
+            //       percentCompleted: 100,
+            //       fileKey: "",
+            //       versionFile: "",
+            //     },
+            //   });
+            // }
+            return new Promise((resolve, reject) => {
+                if (filesNameUploadFail.length === files.length)
+                    reject("Fail to upload all files");
+                else
+                    resolve({
+                        uploadFail: {
+                            totalFile: filesNameUploadFail.length,
+                            filesName: filesNameUploadFail,
+                        },
+                        uploadSuccess: {
+                            totalFile: files.length - filesNameUploadFail.length,
+                            files: filesUploadSuccess.map((file) => ({
+                                fileName: file.customFileName ?? file.file.webkitRelativePath,
+                                versionFile: file.versionFile,
+                            })),
+                        },
+                    });
+            });
+        }
+        catch (error) {
+            console.error("uploadMultiFile", error);
+            if (error instanceof Error && error.message === "Upload cancelled") {
+                return new Promise((resolve, reject) => {
+                    reject({
+                        errorCode: "ClientAbort",
+                        message: "Upload cancelled",
+                    });
+                });
+            }
+            return new Promise((resolve, reject) => {
+                reject(error);
+            });
+        }
+    }
+    async uploadMultiFileRetry(bucketName, files, accessToken, cancellationToken, maxWebWorker, reFreshToken, percentOfChild, prefix, worker, dataUploadId) {
+        try {
+            if (cancellationToken.signal.aborted) {
+                throw new Error("Upload cancelled");
+            }
+            const service = new ServiceIntegration();
+            const batchSize = 2000;
+            const triggerNextBatchAt = 1000;
+            let currentBatchIndex = 0;
+            let filesUploadFail = [];
+            let filesUploadSuccess = [];
+            // Atomic counter for uploaded files
+            let isFetchingNextBatch = false;
+            // Function to fetch presignUrls for a batch
+            const fetchPresignUrlsForBatch = async (batchFiles) => {
+                const multiPresignUrl = await service.generateMultiPresignedUrl(bucketName, batchFiles
+                    .filter((x) => x.file.size <= ConfigFileRules.ChunkSize)
+                    .map((file) => {
+                    const customFileName = file.customFileName ?? file.file.webkitRelativePath;
+                    return `${prefix ?? ""}${customFileName.startsWith("/")
+                        ? customFileName.slice(1)
+                        : customFileName}`;
+                }), accessToken, cancellationToken);
+                if (multiPresignUrl) {
+                    batchFiles.forEach((file) => {
+                        const customFileName = file.customFileName ?? file.file.webkitRelativePath;
+                        const fileName = `${prefix ?? ""}${customFileName.startsWith("/")
+                            ? customFileName.slice(1)
+                            : customFileName}`;
+                        const preSignUrl = multiPresignUrl.urls[fileName];
+                        if (preSignUrl) {
+                            file.preSignUrl = {
+                                url: preSignUrl,
+                                headers: multiPresignUrl.headers,
+                            };
+                        }
+                    });
+                }
+                return multiPresignUrl;
+            };
+            // Function to prepare next batch
+            const prepareNextBatch = async () => {
+                if (isFetchingNextBatch ||
+                    !((currentBatchIndex + 1) * batchSize < files.length))
+                    return;
+                isFetchingNextBatch = true;
+                try {
+                    const nextBatchStart = (currentBatchIndex + 1) * batchSize;
+                    const nextBatchEnd = Math.min((currentBatchIndex + 2) * batchSize, files.length);
+                    const nextBatchFiles = files.slice(nextBatchStart, nextBatchEnd);
+                    await fetchPresignUrlsForBatch(nextBatchFiles);
+                }
+                finally {
+                    isFetchingNextBatch = false;
+                }
+            };
+            // init worker
+            const workerPorts = [];
+            const maxWorker = files.length < maxWebWorker ? files.length : maxWebWorker;
+            for (let index = 0; index < maxWorker; index++) {
+                const channel = new MessageChannel();
+                const worker = new Worker(new URL("workerUploadSingleFile", import.meta.url));
+                worker.postMessage({ port: channel.port2 }, [channel.port2]);
+                workerPorts.push(channel.port1);
+                this.workersStatus.push({
+                    worker: worker,
+                    taskNumber: 0,
+                    id: index,
+                    taskHandle: 0,
+                });
+            }
+            if (worker) {
+                worker.postMessage({ workerPorts }, workerPorts);
+            }
+            while (currentBatchIndex * batchSize < files.length) {
+                const batchStart = currentBatchIndex * batchSize;
+                const batchEnd = Math.min((currentBatchIndex + 1) * batchSize, files.length);
+                const batchFiles = files.slice(batchStart, batchEnd);
+                // Get presignUrls for current batch
+                await fetchPresignUrlsForBatch(batchFiles);
+                const maxLimit = batchFiles.length < ConfigFileRules.LimitFile
+                    ? batchFiles.length
+                    : ConfigFileRules.LimitFile;
+                const limit = pLimit(maxLimit);
+                const tasks = batchFiles.map((file, idx) => limit(async () => {
+                    if (cancellationToken.signal.aborted)
+                        throw new Error("Upload cancelled");
+                    try {
+                        let arrayBuffer = await file.file.arrayBuffer();
+                        const res = await this.uploadSingleFile({
+                            ...file,
+                            bucketName,
+                            arrayBuffer: arrayBuffer,
+                            index: idx,
+                            requestId: `${idx}-${Date.now()}`,
+                            fullName: `${prefix ?? ""}${(file.customFileName ?? file.file.webkitRelativePath).startsWith("/")
+                                ? (file.customFileName ?? file.file.webkitRelativePath).slice(1)
+                                : file.customFileName ?? file.file.webkitRelativePath}`,
+                            accessToken,
+                            percentOfChild,
+                            cancellationToken,
+                            dataUploadId,
+                        });
+                        arrayBuffer = null;
+                        filesUploadSuccess.push({
+                            ...file,
+                            versionFile: res.responseUpload?.versionFile,
+                        });
+                        if (idx === triggerNextBatchAt) {
+                            prepareNextBatch();
+                        }
+                    }
+                    catch (err) {
+                        filesUploadFail.push(file);
+                    }
+                }));
+                await Promise.allSettled(tasks);
+                currentBatchIndex++;
+            }
+            return {
+                filesUploadFail,
+                filesUploadSuccess,
+            };
+        }
+        catch (error) {
+            console.error("uploadMultiFileRetry", error);
+            // Cleanup workers on error
+            this.workersStatus.forEach((workerStatus) => {
+                workerStatus.worker.terminate();
+            });
+            this.workersStatus = [];
+            if (error instanceof Error && error.message === "Upload cancelled") {
+                throw error; // Re-throw cancel error to be handled by caller
+            }
+            return undefined;
+        }
+    }
+    uploadSingleFile = async (request) => {
+        const workerStatus = this.workersStatus.find((x) => x.taskNumber < ConfigFileRules.TaskCurrently);
+        if (!workerStatus)
+            return Promise.reject("No worker available");
+        // Check cancellation before starting
+        if (request.cancellationToken?.signal.aborted) {
+            return Promise.reject(new Error("Upload cancelled"));
+        }
+        // increase task number
+        workerStatus.taskNumber++;
+        const worker = workerStatus.worker;
+        return new Promise((resolve, reject) => {
+            if (typeof Worker !== "undefined") {
+                worker.addEventListener("message", (message) => {
+                    if (message.data.requestId !== request.requestId)
+                        return;
+                    workerStatus.taskNumber--;
+                    if (message.data && message.data.status === StatusWorker.Success) {
+                        request.percentOfChild &&
+                            request.percentOfChild({
+                                fileKey: message.data.fileKey,
+                                versionFile: message.data.responseUpload.versionFile,
+                            });
+                        resolve(message.data);
+                    }
+                    else {
+                        reject(message.data);
+                    }
+                });
+                worker.addEventListener("error", (error) => {
+                    workerStatus.taskNumber--;
+                    console.error(error);
+                    reject(error);
+                });
+                // Add abort handler to worker
+                const abortHandler = () => {
+                    worker.postMessage({
+                        type: "abort",
+                        requestId: request.requestId,
+                    });
+                    worker.terminate();
+                    reject(new Error("Upload cancelled"));
+                };
+                request.cancellationToken?.signal.addEventListener("abort", abortHandler);
+                const newData = {
+                    bucketName: request.bucketName,
+                    fullName: request.fullName,
+                    arrayBuffer: request.arrayBuffer,
+                    requestId: request.requestId,
+                    workerId: workerStatus.id,
+                    accessToken: request.accessToken,
+                    fileKey: request.fileKey,
+                    initUpload: request.initUpload,
+                    isGetInfo: request.isGetInfo,
+                    preSignUrl: request.preSignUrl,
+                    dataUploadId: request.dataUploadId,
+                };
+                worker.postMessage(newData, [request.arrayBuffer]);
+                // Cleanup abort handler when promise resolves or rejects
+                return () => {
+                    request.cancellationToken?.signal.removeEventListener("abort", abortHandler);
+                };
+            }
+            else {
+                console.error("Web Workers are not supported in this environment.");
+                reject("Web Workers are not supported in this environment.");
+            }
+        });
+    };
+    //#endregion
+    //#region Download file
+    // public async downloadFile(
+    //   bucketName: string,
+    //   fileName: string,
+    //   cancellationToken: AbortController,
+    //   onProgress?: (percentCompleted: number) => void,
+    //   maxWebWorker?: number
+    // ) {
+    //   try {
+    //     maxWebWorker = maxWebWorker ? maxWebWorker : ConfigFileRules.MaxWebWorker;
+    //     var serviceIntegrate = new ServiceIntegration();
+    //     const file = await serviceIntegrate.getObjectDetail(
+    //       bucketName,
+    //       fileName,
+    //       this.accessToken
+    //     );
+    //     if (!file || !file.contentLength || file.contentLength === 0) {
+    //       return new Promise((resolve, reject) => {
+    //         reject("File not found");
+    //       });
+    //     }
+    //     const url = await serviceIntegrate.getUrlToDownload(
+    //       bucketName,
+    //       fileName,
+    //       this.accessToken
+    //     );
+    //     if (!url)
+    //       return new Promise((resolve, reject) => {
+    //         reject("Fail to get url download");
+    //       });
+    //     const numberOfChunks = Math.ceil(
+    //       file.contentLength / ConfigFileRules.ChunkSize
+    //     );
+    //     const maxWorker = Math.min(numberOfChunks, maxWebWorker);
+    //     const maxLimit = Math.min(numberOfChunks, ConfigFileRules.LimitFile);
+    //     const limit = pLimit(maxLimit);
+    //     let start = 0;
+    //     const totalSize = file.contentLength;
+    //     for (let index = 0; index < maxWorker; index++) {
+    //       this.workersStatus.push({
+    //         worker: new Worker(
+    //           new URL("workerDownloadSingleFile", import.meta.url)
+    //         ),
+    //         taskNumber: 0,
+    //         id: index,
+    //         taskHandle: 0,
+    //       });
+    //     }
+    //     const newFileName = fileName.split("/").at(-1);
+    //     const fileWriter = streamSaver.createWriteStream(`${newFileName}`);
+    //     const writer = fileWriter.getWriter();
+    //     const chunksQueue: (Uint8Array | undefined)[] = [];
+    //     let nextChunkIndex = 0;
+    //     const handleChunk = async (chunk: Uint8Array, index: number) => {
+    //       chunksQueue[index] = chunk;
+    //       while (chunksQueue[nextChunkIndex]) {
+    //         nextChunkIndex++; // hack duplicate chunk :D
+    //         await writer.write(chunksQueue[nextChunkIndex - 1]);
+    //         chunksQueue[nextChunkIndex - 1] = undefined; // Clear memory
+    //       }
+    //     };
+    //     const chunksData: any[] = [];
+    //     Array.from({ length: numberOfChunks }, (_, index) => {
+    //       const end = Math.min(
+    //         start + ConfigFileRules.ChunkSize - 1,
+    //         totalSize - 1
+    //       );
+    //       chunksData.push({
+    //         url: url,
+    //         start: start,
+    //         end: end,
+    //         index: index,
+    //         requestId: `${index + 1}-${Date.now()}`,
+    //       });
+    //       start += ConfigFileRules.ChunkSize;
+    //     });
+    //     // hack to client chose location to save file
+    //     const firstChunk = chunksData.shift();
+    //     const firstData = await this.downloadSingleLargeFile(
+    //       firstChunk.index,
+    //       firstChunk.url,
+    //       firstChunk.start,
+    //       firstChunk.end,
+    //       firstChunk.requestId
+    //     );
+    //     await handleChunk(new Uint8Array(firstData.chunk), firstData.index);
+    //     const tasks = chunksData.map((data) => {
+    //       return limit(async () => {
+    //         let task = await this.downloadSingleLargeFile(
+    //           data.index,
+    //           data.url,
+    //           data.start,
+    //           data.end,
+    //           data.requestId
+    //         );
+    //         await handleChunk(new Uint8Array(task.chunk), task.index);
+    //         return task;
+    //       });
+    //     });
+    //     await Promise.all(tasks);
+    //     await writer.close();
+    //     this.workersStatus.forEach((workerStatus) => {
+    //       workerStatus.worker.terminate();
+    //     });
+    //     this.workersStatus = [];
+    //     return new Promise((resolve, reject) => {
+    //       resolve({
+    //         downloadSuccess: {
+    //           totalFile: numberOfChunks,
+    //           blobUrl: fileWriter,
+    //           fileName: `${newFileName}`,
+    //         },
+    //       });
+    //     });
+    //   } catch (error) {
+    //     console.error("downloadLargeFile", error);
+    //     return new Promise((resolve, reject) => {
+    //       reject(error);
+    //     });
+    //   }
+    // }
+    async downloadSingleLargeFile(index, url, start, end, requestId) {
+        try {
+            const workerStatus = this.workersStatus.find((x) => x.taskNumber < ConfigFileRules.TaskCurrently);
+            if (!workerStatus)
+                return Promise.reject("No worker available");
+            // increase task number
+            workerStatus.taskNumber++;
+            const worker = workerStatus.worker;
+            return new Promise((resolve, reject) => {
+                if (typeof Worker !== "undefined") {
+                    worker.addEventListener("message", async (message) => {
+                        if (message.data.requestId !== requestId)
+                            return;
+                        workerStatus.taskNumber--;
+                        if (message.data && message.data.status === StatusWorker.Success) {
+                            resolve(message.data);
+                        }
+                        else {
+                            reject(message.data);
+                        }
+                    });
+                    worker.addEventListener("error", (error) => {
+                        workerStatus.taskNumber--;
+                        console.error(error);
+                        reject(error);
+                    });
+                    const newData = {
+                        index: index,
+                        url: url,
+                        start: start,
+                        end: end,
+                        requestId: requestId,
+                    };
+                    worker.postMessage(newData);
+                }
+                else {
+                    console.error("Web Workers are not supported in this environment.");
+                    reject("Web Workers are not supported in this environment.");
+                }
+            });
+        }
+        catch (error) {
+            console.error(`Error when download file: ${error}`);
+            throw error;
+        }
+    }
+    //#endregion
+    //#region Translate
+    async translateFile(request) {
+        return await this.baseAction((accessToken) => {
+            return TranslateFile(accessToken, request);
+        });
+    }
+    async getStatusTranslate(request) {
+        return await this.baseAction((accessToken) => {
+            return GetStatusTranslate(accessToken, request);
+        });
+    }
+    async getStatusTranslateFile(request) {
+        return await this.baseAction((accessToken) => {
+            return GetStatusTranslateFile(accessToken, request);
+        });
+    }
+    async getEPSGRegionCode() {
+        return await this.baseAction((accessToken) => {
+            return GetEPSGRegionCode(accessToken);
+        });
+    }
+    async getFileTileSet(translateId) {
+        return await this.baseAction((accessToken) => {
+            return GetFileTileSet(accessToken, translateId);
+        });
+    }
+    //#endregion
+    //#region Authentication
+    async getToken(clientId, clientSecret, scopes) {
+        return await this.baseActionAnonymous(() => {
+            return GetToken(clientId, clientSecret, scopes);
+        });
+    }
+    //#endregion
+    async delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}