@sumaris-net/ngx-components 1.12.3 → 1.12.6

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

@@ -25365,9 +25365,15 @@
             return false;
         };
         AppTable.prototype.cancelOrDelete = function (event, row, opts) {
+            // Delete new row
             if (row.id === -1) {
                 this.deleteNewRow(event, row);
             }
+            // Delete existing (bu not editing) row
+            else if (!row.editing) {
+                this.deleteExistingRow(event, row, opts);
+            }
+            // Cancel existing (and editing) row
             else {
                 this.cancelExistingRow(event, row, opts);
             }
@@ -25532,6 +25538,7 @@
          * @param event
          * @param row
          * @param opts Use interactive=false to avoid user interaction (e.g. user confirmation)
+         *  Use skipIfLoading=false to force deletion even if table is busy
          */
         AppTable.prototype.deleteRow = function (event, row, opts) {
             return __awaiter(this, void 0, void 0, function () {
@@ -25551,6 +25558,7 @@
          * @param event
          * @param rows
          * @param opts Use interactive=false to avoid user interaction (e.g. user confirmation)
+         *    Use skipIfLoading=false to force deletion even if table is busy
          */
         AppTable.prototype.deleteRows = function (event, rows, opts) {
             var _a;
@@ -25566,10 +25574,12 @@
                             if (event === null || event === void 0 ? void 0 : event.defaultPrevented)
                                 return [2 /*return*/, 0]; // SKip
                             event === null || event === void 0 ? void 0 : event.preventDefault();
-                            if (!this._enabled)
-                                return [2 /*return*/, 0];
-                            if (this.loading || isEmptyArray(rows))
-                                return [2 /*return*/, 0];
+                            if (!this._enabled || isEmptyArray(rows))
+                                return [2 /*return*/, 0]; // Skip is disabled, or no rows to delete
+                            if (this.loading && (!opts || opts.skipIfLoading !== true)) {
+                                console.warn('[app-table] Skip deleteRows() because table is busy (loading). Use opts.skipLoading = false to force deletion');
+                                return [2 /*return*/, 0]; // Skip if loading
+                            }
                             // Make sure to keep newly created row
                             if (((_a = this.editedRow) === null || _a === void 0 ? void 0 : _a.id) === -1 && this.editedRow.editing && !rows.includes(this.editedRow)) {
                                 confirmed = this.confirmEditCreate();
@@ -25581,21 +25591,33 @@
                             canDelete = _e.sent();
                             if (!canDelete)
                                 return [2 /*return*/, 0]; // Cannot delete
+                            // Reverse row order (on a copy)
+                            // This is a workaround, need because row.delete() has async execution
+                            // and index cache is updated with a delay
+                            rows = rows.slice()
+                                .sort(function (a, b) { return a.id > b.id ? -1 : 1; });
                             if (!this.saveBeforeDelete) return [3 /*break*/, 3];
-                            // Cancel invalid rows (because of save() will fail, if invalid rows exists)
-                            rows = rows.reduce(function (res, row) {
+                            // Exclude invalid rows (because of save() will fail, when exists some invalid rows)
+                            rows = rows.filter(function (row) {
                                 if (row.validator && !row.validator.valid) {
-                                    var deleted = row.id === -1;
-                                    row.cancelOrDelete();
                                     // When deleted (= newly created row) : decrement counter
-                                    if (deleted) {
+                                    if (row.id === -1 || !row.editing) {
+                                        row.delete();
                                         _this.visibleRowCount--;
                                         _this.totalRowCount--;
-                                        return res;
+                                        return false; // Remove this row to the list, because already deleted
+                                    }
+                                    // Mark row as pristine, to avoid row to be saved even if still invalid
+                                    else {
+                                        // Will cancel only (delete will always go into the previous 'if')
+                                        row.cancelOrDelete();
+                                        // Mark row as pristine (if possible)
+                                        _this.checkIfRowPristine(row, { emitEvent: false, onlySelf: true /*avoid propagation to table*/ });
+                                        // Continue: the row will be deleted after the save
                                     }
                                 }
-                                return res.concat(row);
-                            }, []);
+                                return true;
+                            });
                             if (!isNotEmptyArray(rows)) return [3 /*break*/, 3];
                             return [4 /*yield*/, this.saveBeforeAction('delete')];
                         case 2:
@@ -25611,11 +25633,6 @@
                             if (!deleteCount) return [3 /*break*/, 5];
                             if (this.debug)
                                 console.debug('[table] Delete selected rows...');
-                            // Reverse row order (on a copy)
-                            // This is a workaround, need because row.delete() has async execution
-                            // and index cache is updated with a delay
-                            rows = rows.slice()
-                                .sort(function (a, b) { return a.id > b.id ? -1 : 1; });
                             return [4 /*yield*/, this._dataSource.deleteAll(rows)];
                         case 4:
                             _e.sent();
@@ -25816,6 +25833,7 @@
             }); });
         };
         AppTable.prototype.escapeEditingRow = function (event, row) {
+            var _this = this;
             row = row || this.editedRow;
             if (!row || !row.editing)
                 return;
@@ -25826,21 +25844,31 @@
                 event.preventDefault();
                 event.stopPropagation();
             }
-            // If new row is invalid: delete silently
-            if (row.id === -1 && row.validator.invalid) {
-                this.deleteNewRow(event, row);
+            // If new row (no id)
+            if (row.id === -1) {
+                if (row.validator) {
+                    // If pending: Wait end of validation, then loop
+                    if (row.validator.pending) {
+                        AppFormUtils.waitWhilePending(row.validator).then(function () { return _this.escapeEditingRow(event, row); });
+                        return;
+                    }
+                    // Row is invalid: delete the row
+                    if (row.validator.invalid) {
+                        this.deleteNewRow(event, row);
+                        return;
+                    }
+                }
             }
-            // If exists
+            // If the row exists (has an id)
             else {
-                // cancel (if confirmation)
+                // need to call cancel function (if confirmation will be call before before)
                 if (this.confirmBeforeCancel) {
                     this.cancelExistingRow(event, row, { keepEditing: false });
-                }
-                // Or validate, if no confirmation
-                else {
-                    this.confirmEditCreate(event, row);
+                    return;
                 }
             }
+            // By default, try to confirm the row
+            this.confirmEditCreate(event, row);
         };
         AppTable.prototype.translateControlPath = function (path) {
             // Can be override by subclasses, to resolve all field name
@@ -26337,6 +26365,8 @@
             }
         };
         AppTable.prototype.deleteNewRow = function (event, row) {
+            if (row.id !== -1)
+                throw new Error('Row must have id = -1');
             event === null || event === void 0 ? void 0 : event.stopPropagation();
             this.selection.clear();
             this.editedRow = undefined; // unselect row
@@ -26346,9 +26376,21 @@
             this.totalRowCount--;
             this.visibleRowCount--;
         };
+        AppTable.prototype.deleteExistingRow = function (event, row, opts) {
+            // Make sure row will be cancelled, and NOT deleted
+            if (row.id === -1)
+                throw new Error('Row must have an id');
+            if (event === null || event === void 0 ? void 0 : event.defaultPrevented)
+                return 0; // SKip
+            event === null || event === void 0 ? void 0 : event.preventDefault();
+            this.deleteRow(null, row, opts);
+        };
         AppTable.prototype.cancelExistingRow = function (event, row, opts) {
             var _this = this;
-            var _a, _b, _c;
+            var _a;
+            // Make sure row will be cancelled, and NOT deleted
+            if (row.id === -1 || !row.editing)
+                throw new Error('Row cannot be canceling, but only deleting');
             var confirmed = (!opts || opts.interactive !== false);
             // Ask user confirmation, if cancel
             if (!confirmed && ((_a = row.validator) === null || _a === void 0 ? void 0 : _a.dirty) && (this.confirmBeforeCancel || this.onBeforeCancelRows.observers.length > 0)) {
@@ -26366,17 +26408,32 @@
             this._dataSource.cancelOrDelete(row);
             this.onCancelOrDeleteRow.next(row);
             // Mark row as pristine
-            var markRowAsPristine = ((_b = this.dataSource) === null || _b === void 0 ? void 0 : _b.options.keepOriginalDataAfterConfirm) === true;
-            if (markRowAsPristine) {
-                (_c = row.validator) === null || _c === void 0 ? void 0 : _c.markAsPristine();
-                // Check if table is now pristine
-                this.checkIfPristine();
-            }
+            this.checkIfRowPristine(row);
             // Restore editing state
             if (keepEditing) {
                 this.editRow(undefined, row);
             }
         };
+        AppTable.prototype.checkIfRowPristine = function (row, opts) {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function () {
+                var markRowAsPristine;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            markRowAsPristine = ((_a = this.dataSource) === null || _a === void 0 ? void 0 : _a.options.keepOriginalDataAfterConfirm) === true;
+                            if (!markRowAsPristine) return [3 /*break*/, 2];
+                            (_b = row.validator) === null || _b === void 0 ? void 0 : _b.markAsPristine();
+                            if (!(!opts || opts.onlySelf !== true)) return [3 /*break*/, 2];
+                            return [4 /*yield*/, this.checkIfPristine(opts)];
+                        case 1:
+                            _e.sent();
+                            _e.label = 2;
+                        case 2: return [2 /*return*/];
+                    }
+                });
+            });
+        };
         AppTable.prototype.checkIfPristine = function (opts) {
             return __awaiter(this, void 0, void 0, function () {
                 var rows, pristine;