@sumaris-net/ngx-components 1.12.4 → 1.12.5

package/fesm2015/sumaris-net.ngx-components.js

@@ -21924,9 +21924,15 @@ class AppTable {
         return false;
     }
     cancelOrDelete(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);
         }
@@ -22083,10 +22089,12 @@ class AppTable {
             if (event === null || event === void 0 ? void 0 : event.defaultPrevented)
                 return 0; // SKip
             event === null || event === void 0 ? void 0 : event.preventDefault();
-            if (!this._enabled)
-                return 0;
-            if (this.loading || isEmptyArray(rows))
-                return 0;
+            if (!this._enabled || isEmptyArray(rows))
+                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 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)) {
                 const confirmed = this.confirmEditCreate();
@@ -22104,25 +22112,27 @@ class AppTable {
                 .sort((a, b) => a.id > b.id ? -1 : 1);
             // If data need to be saved first
             if (this.saveBeforeDelete) {
-                // Cancel invalid rows (because of save() will fail, if invalid rows exists)
-                rows = rows.reduce((res, row) => {
+                // Exclude invalid rows (because of save() will fail, when exists some invalid rows)
+                rows = rows.filter(row => {
                     if (row.validator && !row.validator.valid) {
                         // When deleted (= newly created row) : decrement counter
                         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
+                        // Mark row as pristine, to avoid row to be saved even if still invalid
                         else {
-                            row.cancelOrDelete(); // Will cancel only (delete will always go into the previous 'if')
-                            row.validator.markAsPristine();
+                            // 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;
+                });
                 // Apply save, only if there is still some rows to delete
                 // WARN: If no more rows (e.g. because all has been cancelled) then continue anyway to clear editedRow and selection (issue IMAGINE-669)
                 if (isNotEmptyArray(rows)) {
@@ -22287,21 +22297,31 @@ class AppTable {
             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(() => 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);
     }
     translateControlPath(path) {
         // Can be override by subclasses, to resolve all field name
@@ -22725,6 +22745,8 @@ class AppTable {
         }
     }
     deleteNewRow(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
@@ -22734,8 +22756,20 @@ class AppTable {
         this.totalRowCount--;
         this.visibleRowCount--;
     }
+    deleteExistingRow(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);
+    }
     cancelExistingRow(event, row, opts) {
-        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');
         const 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)) {
@@ -22753,17 +22787,26 @@ class AppTable {
         this._dataSource.cancelOrDelete(row);
         this.onCancelOrDeleteRow.next(row);
         // Mark row as pristine
-        const 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);
         }
     }
+    checkIfRowPristine(row, opts) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            // Mark row as pristine
+            const markRowAsPristine = ((_a = this.dataSource) === null || _a === void 0 ? void 0 : _a.options.keepOriginalDataAfterConfirm) === true;
+            if (markRowAsPristine) {
+                (_b = row.validator) === null || _b === void 0 ? void 0 : _b.markAsPristine();
+                // Check if table is now pristine
+                if (!opts || opts.onlySelf !== true) {
+                    yield this.checkIfPristine(opts);
+                }
+            }
+        });
+    }
     checkIfPristine(opts) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.dirty)