bruce-models 5.8.7 → 5.8.8

package/dist/bruce-models.umd.js

@@ -8293,20 +8293,51 @@
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
-                const FILE_PORTION_SIZE = 50000000; // 50MB.
+                const getOptimalConcurrency = (fileSize) => {
+                    // < 50MB
+                    if (fileSize < 50 * 1024 * 1024) {
+                        return 2;
+                    }
+                    // < 200MB
+                    if (fileSize < 200 * 1024 * 1024) {
+                        return 3;
+                    }
+                    // >= 200MB
+                    return 4;
+                };
+                const concurrentUploads = getOptimalConcurrency(file.size);
+                const FILE_PORTION_SIZE = 35000000; // 35MB.
                 let fileSize = file.size;
-                let fileOffset = 0;
-                let filePartsCount = fileSize / FILE_PORTION_SIZE;
+                let filePartsCount = Math.ceil(fileSize / FILE_PORTION_SIZE);
                 let t = Math.trunc(filePartsCount);
                 filePartsCount = filePartsCount > t ? t + 1 : t;
-                let filePartIndex = 1;
-                let uploadToken = exports.ObjectUtils.UId();
-                let data;
-                while (fileOffset < fileSize) {
-                    let partSize = Math.min(FILE_PORTION_SIZE, fileSize - fileOffset);
-                    let retryCount = 5;
-                    let retryWait = 1000;
+                // Uploaded number of bytes so far.
+                let uploaded = 0;
+                // Part index -> uploaded amount.
+                // When the part finishes uploading, we remove from here and add to uploaded.
+                let uploadedPending = new Map();
+                const updateProgress = () => {
+                    let total = uploaded;
+                    uploadedPending.forEach((value) => {
+                        total += (value || 0);
+                    });
+                    const percent = Math.round((total / fileSize) * 100);
+                    onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                        percent: percent,
+                        uploaded: false
+                    });
+                };
+                const uploadToken = exports.ObjectUtils.UId();
+                const uploadPart = (filePartIndex) => __awaiter(this, void 0, void 0, function* () {
+                    const fileOffset = filePartIndex * FILE_PORTION_SIZE;
+                    const partSize = Math.min(FILE_PORTION_SIZE, fileSize - fileOffset);
+                    let retryCount = 3;
+                    let retryWait = 3000;
+                    let data = null;
                     while (retryCount > 0) {
+                        // Reset pending loaded in case this is a retry.
+                        uploadedPending.set(filePartIndex, 0);
+                        updateProgress();
                         try {
                             const blob = file.slice(fileOffset, fileOffset + partSize);
                             const partialFile = new File([blob], file.name, { type: file.type });
@@ -8314,20 +8345,26 @@
                             formData.append("originalFileName", file.name);
                             formData.append("token", uploadToken);
                             formData.append("count", "" + filePartsCount);
-                            formData.append("part", "" + filePartIndex);
+                            // Not 0-based.
+                            formData.append("part", "" + (filePartIndex + 1));
                             formData.append("file", partialFile);
                             const reqParams = exports.Api.PrepReqParams(req);
                             reqParams.formData = formData;
                             reqParams.onProgress = (progress) => {
-                                const sofar = fileOffset + progress.loaded;
-                                const percent = Math.round((sofar / file.size) * 100);
-                                onProgress === null || onProgress === void 0 ? void 0 : onProgress({
-                                    percent: percent,
-                                    uploaded: false
-                                });
+                                const loaded = progress.loaded;
+                                uploadedPending.set(filePartIndex, loaded);
+                                updateProgress();
                             };
                             data = yield api.UPLOAD(url, partialFile, reqParams);
                             retryCount = 0;
+                            uploaded += partSize;
+                            // Flush the pending upload.
+                            const pendingLoaded = uploadedPending.get(filePartIndex) || 0;
+                            uploaded += pendingLoaded;
+                            uploadedPending.delete(filePartIndex);
+                            // Call onProgress since we completed a portion.
+                            // This helps us know progress even when the request callback isn't working properly.
+                            updateProgress();
                         }
                         catch (up) {
                             retryCount -= 1;
@@ -8338,20 +8375,34 @@
                             retryWait = retryWait * 2;
                         }
                     }
-                    fileOffset += partSize;
-                    filePartIndex++;
-                    // Call onProgress since we completed a portion.
-                    // This helps us know progress even when the request callback isn't working properly.
-                    onProgress === null || onProgress === void 0 ? void 0 : onProgress({
-                        percent: Math.round((fileOffset / fileSize) * 100),
-                        uploaded: false
-                    });
+                    return { index: filePartIndex, data };
+                });
+                let results = [];
+                for (let i = 0; i < filePartsCount; i += concurrentUploads) {
+                    const uploadPromises = [];
+                    for (let j = 0; j < concurrentUploads && (i + j) < filePartsCount; j++) {
+                        uploadPromises.push(uploadPart(i + j));
+                    }
+                    const batchResults = yield Promise.all(uploadPromises);
+                    // Sorting to maintain promise order.
+                    // Helps determine what the last part was.
+                    results.push(...batchResults.sort((a, b) => a.index - b.index).map(r => r.data));
                 }
                 onProgress === null || onProgress === void 0 ? void 0 : onProgress({
                     percent: 100,
                     uploaded: true
                 });
-                return data;
+                // Look for the explicitly stated final part.
+                const final = results.find(x => x.RemainingParts == 0);
+                if (final) {
+                    return final;
+                }
+                // Look for the last part.
+                else if (results.length) {
+                    return results[results.length - 1];
+                }
+                // :(
+                return null;
             });
         }
         Uploader.DoMultiPartUpload = DoMultiPartUpload;
@@ -15055,7 +15106,7 @@
     })(exports.Scenario || (exports.Scenario = {}));
 
     // This is updated with the package.json version on build.
-    const VERSION = "5.8.7";
+    const VERSION = "5.8.8";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;