@sumaris-net/ngx-components 1.16.2 → 1.16.3

package/bundles/sumaris-net.ngx-components.umd.js

@@ -20308,53 +20308,59 @@
                 .then(function () {
                 if (opts === null || opts === void 0 ? void 0 : opts.maxProgression)
                     progression.next(opts.maxProgression);
-                if (opts === null || opts === void 0 ? void 0 : opts.progression)
-                    opts.progression.complete();
+                progression.complete();
             })
                 .catch(function (err) { return progression.error(err); });
             return progression;
         };
         JobUtils.fetchAllPages = function (loadPageFn, opts) {
-            var _a;
             return __awaiter(this, void 0, void 0, function () {
-                var maxProgression, total, pageCount, progressionStep, currentPageDataCount, fetchSize, offset, data, res, actualProgression, lastProgressionStep;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
+                var maxProgression, progression, total, pageCount, progressionStep, currentPageDataCount, fetchSize, offset, data, res;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
                         case 0:
-                            maxProgression = opts && opts.maxProgression || undefined;
-                            fetchSize = opts && opts.fetchSize || 1000;
+                            maxProgression = toNumber(opts === null || opts === void 0 ? void 0 : opts.maxProgression, 100);
+                            progression = opts === null || opts === void 0 ? void 0 : opts.progression;
+                            fetchSize = toNumber(opts === null || opts === void 0 ? void 0 : opts.fetchSize, 1000);
+                            if (fetchSize <= 0)
+                                throw new Error('Unable to fetch pages: invalid fetchSize: ' + fetchSize);
                             offset = 0;
                             data = [];
-                            _b.label = 1;
+                            _a.label = 1;
                         case 1:
                             if (opts && opts.logPrefix)
                                 console.debug(opts.logPrefix + " Fetching page #" + offset / fetchSize + "...");
                             return [4 /*yield*/, loadPageFn(offset, fetchSize)];
                         case 2:
-                            res = _b.sent();
+                            res = _a.sent();
+                            // Concat to previous result
                             data = data.concat(res.data);
+                            // Compute variables, for next loop
                             currentPageDataCount = res.data && res.data.length || 0;
                             offset += currentPageDataCount;
-                            // Set total count (only if not already set)
+                            // Set total count (only once)
                             if (isNil(total) && isNotNil(res.total)) {
                                 total = res.total;
                                 // Compute the number of page
                                 pageCount = Math.round(res.total / fetchSize + 0.5); // Round to HALF_UP integer
-                                actualProgression = Math.max(0, toNumber(opts && ((_a = opts.progression) === null || _a === void 0 ? void 0 : _a.value), 0));
-                                progressionStep = maxProgression
-                                    ? (maxProgression - actualProgression) / pageCount
-                                    : undefined /*if 0 reset to undefined*/;
+                                // Compute step, by dividing maxProgression by number of page
+                                if (progression) {
+                                    progressionStep = maxProgression / pageCount;
+                                    // DEBUG
+                                    if (opts && opts.logPrefix)
+                                        console.debug(opts.logPrefix + " {pageCount: " + pageCount + ", progression: " + progression.value + ", pageProgressionStep: " + progressionStep + "}");
+                                }
                             }
                             // Increment progression on each iteration (if possible)
-                            if (opts && opts.progression && isNotNil(progressionStep)) {
-                                opts.progression.next(opts.progression.value + progressionStep);
+                            if (isNotNil(progressionStep)) {
+                                progression.next(progression.value + progressionStep);
                             }
-                            if (opts && opts.onPageLoaded)
+                            if (opts === null || opts === void 0 ? void 0 : opts.onPageLoaded)
                                 opts.onPageLoaded(res);
-                            _b.label = 3;
+                            _a.label = 3;
                         case 3:
                             if (currentPageDataCount > 0 && ((isNil(total) && currentPageDataCount === fetchSize) || (isNotNil(total) && (offset < total)))) return [3 /*break*/, 1];
-                            _b.label = 4;
+                            _a.label = 4;
                         case 4:
                             // Complete progression to reach progressionStep value (because of round)
                             if (isNotNil(progressionStep)) {
@@ -20364,14 +20370,19 @@
                                     total = data.length;
                                     pageCount = Math.round(data.length / fetchSize + 0.5);
                                 }
-                                lastProgressionStep = opts.maxProgression - (progressionStep * pageCount);
-                                if (opts && opts.progression && lastProgressionStep > 0) {
-                                    opts.progression.next(opts.progression.value + lastProgressionStep);
-                                }
+                                // Compute final increment, using the real page count
+                                progressionStep = Math.max(0, maxProgression - (progressionStep * pageCount));
+                            }
+                            // Or increment once (e.g. when total is not known, in received LoadResult)
+                            else if (progression) {
+                                progressionStep = maxProgression;
                             }
-                            // Or increment once
-                            else if (opts && opts.progression && opts.maxProgression) {
-                                opts.progression.next(opts.maxProgression);
+                            // DEBUG
+                            if (opts && opts.logPrefix)
+                                console.debug(opts.logPrefix + " All pages fetched - {progression: " + progression.value + ", lastProgressionStep: " + progressionStep);
+                            // Final increment
+                            if (progression && progressionStep > 0) {
+                                progression.next(progression.value + progressionStep);
                             }
                             return [2 /*return*/, {
                                     data: data,