@sumaris-net/ngx-components 1.20.0-rc1 → 1.20.0-rc4

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

@@ -24961,6 +24961,10 @@
             enumerable: false,
             configurable: true
         });
+        EntitiesTableDataSource.prototype.connect = function (collectionViewer) {
+            // DEBUG console.debug("[entities-datasource] connect");
+            return _super_1.prototype.connect.call(this, collectionViewer);
+        };
         EntitiesTableDataSource.prototype.disconnect = function (collectionViewer) {
             _super_1.prototype.disconnect.call(this, collectionViewer);
             this._stopWatching$.next();
@@ -25270,68 +25274,116 @@
             });
         };
         EntitiesTableDataSource.prototype.deleteAll = function (rows) {
-            var _this = this;
-            this.markAsLoading();
-            var data = this.getDataFromRows(rows);
-            var rowsById = rows.reduce(function (res, row) {
-                res[row.id] = row;
-                return res;
-            }, {});
-            var self = this;
-            var inheritedDelete = _super_1.prototype.delete;
-            return this.dataService.deleteAll(data, this.serviceOptions)
-                .catch(function (err) { return _this.handleErrorPromise(err); })
-                .then(function () {
-                // Workaround, to be sure all rows has been deleted
-                // Sometimes, the service miss deletion, or GrapQHl cache remove failed
-                var rowNotDeleted = Object.getOwnPropertyNames(rowsById).reduce(function (res, id) {
-                    var row = rowsById[id];
-                    var present = self.getRow(+id) === row;
-                    return present ? res.concat(row) : res;
-                }, []).sort(function (a, b) { return a.id > b.id ? -1 : 1; });
-                // Apply missing deletion
-                if (isNotEmptyArray(rowNotDeleted)) {
-                    console.warn("[table-datasource] Force deletion of " + rowNotDeleted.length + " rows (Is service applying deletion to observable ?)");
-                    rowNotDeleted.forEach(function (r) { return inheritedDelete.call(self, r.id); });
-                }
-                _this.loadingSubject.next(false);
+            var _super = Object.create(null, {
+                delete: { get: function () { return _super_1.prototype.delete; } }
+            });
+            return __awaiter(this, void 0, void 0, function () {
+                var data, rowsById, self, rowNotDeleted, err_2;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            this.markAsLoading();
+                            data = this.getDataFromRows(rows);
+                            rowsById = rows.reduce(function (res, row) {
+                                res[row.id] = row;
+                                return res;
+                            }, {});
+                            self = this;
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, 5, 6, 7]);
+                            return [4 /*yield*/, this.dataService.deleteAll(data, this.serviceOptions)];
+                        case 2:
+                            _a.sent();
+                            rowNotDeleted = Object.getOwnPropertyNames(rowsById).reduce(function (res, id) {
+                                var row = rowsById[id];
+                                var present = self.getRow(+id) === row;
+                                return present ? res.concat(row) : res;
+                            }, []).sort(function (a, b) { return a.id > b.id ? -1 : 1; });
+                            if (!isNotEmptyArray(rowNotDeleted)) return [3 /*break*/, 4];
+                            console.warn("[table-datasource] Force deletion of " + rowNotDeleted.length + " rows (Is service applying deletion to observable ?)");
+                            return [4 /*yield*/, Promise.all(rowNotDeleted.map(function (r) { return _super.delete.call(_this, r.id); }))];
+                        case 3:
+                            _a.sent();
+                            _a.label = 4;
+                        case 4: return [3 /*break*/, 7];
+                        case 5:
+                            err_2 = _a.sent();
+                            this.handleErrorPromise(err_2);
+                            return [3 /*break*/, 7];
+                        case 6:
+                            this.markAsLoaded();
+                            return [7 /*endfinally*/];
+                        case 7: return [2 /*return*/];
+                    }
+                });
             });
         };
         EntitiesTableDataSource.prototype.getRows = function () {
             return this.rowsSubject.toPromise();
         };
-        EntitiesTableDataSource.prototype.asyncCreateNew = function (insertAt) {
+        EntitiesTableDataSource.prototype.createNew = function (insertAt) {
             var _super = Object.create(null, {
                 createNew: { get: function () { return _super_1.prototype.createNew; } }
             });
             return __awaiter(this, void 0, void 0, function () {
-                var row, res, err_2;
+                var done, row, err_3;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
                             if (this._creating)
                                 return [2 /*return*/]; // Avoid multiple call (should never occur)
                             this._creating = true;
-                            _super.createNew.call(this, insertAt);
-                            row = this.getRow(-1);
-                            if (!(row && this.config.onRowCreated)) return [3 /*break*/, 4];
-                            res = this.config.onRowCreated(row);
-                            if (!(res instanceof Promise)) return [3 /*break*/, 4];
-                            _a.label = 1;
+                            return [4 /*yield*/, _super.createNew.call(this, insertAt)];
                         case 1:
-                            _a.trys.push([1, 3, , 4]);
-                            return [4 /*yield*/, res];
+                            done = _a.sent();
+                            if (!(done && this.config.onRowCreated)) return [3 /*break*/, 5];
+                            row = this.getRow(-1);
+                            _a.label = 2;
                         case 2:
-                            _a.sent();
-                            return [3 /*break*/, 4];
+                            _a.trys.push([2, 4, , 5]);
+                            return [4 /*yield*/, this.config.onRowCreated(row)];
                         case 3:
-                            err_2 = _a.sent();
-                            console.error(err_2 && err_2.message || err_2, err_2);
-                            return [3 /*break*/, 4];
+                            _a.sent();
+                            return [3 /*break*/, 5];
                         case 4:
-                            this._editingRowCount++;
+                            err_3 = _a.sent();
+                            console.error(err_3 && err_3.message || err_3, err_3);
+                            return [3 /*break*/, 5];
+                        case 5:
+                            if (done)
+                                this._editingRowCount++;
                             this._creating = false;
-                            return [2 /*return*/];
+                            return [2 /*return*/, done];
+                    }
+                });
+            });
+        };
+        EntitiesTableDataSource.prototype.createRowValidator = function () {
+            var _super = Object.create(null, {
+                createRowValidator: { get: function () { return _super_1.prototype.createRowValidator; } }
+            });
+            return __awaiter(this, void 0, void 0, function () {
+                var validator, err_4;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, _super.createRowValidator.call(this)];
+                        case 1:
+                            validator = _a.sent();
+                            if (!(validator && this.config.onRowValidator)) return [3 /*break*/, 5];
+                            _a.label = 2;
+                        case 2:
+                            _a.trys.push([2, 4, , 5]);
+                            return [4 /*yield*/, this.config.onRowValidator(validator)];
+                        case 3:
+                            _a.sent();
+                            return [3 /*break*/, 5];
+                        case 4:
+                            err_4 = _a.sent();
+                            console.error(err_4 && err_4.message || err_4, err_4);
+                            return [3 /*break*/, 5];
+                        case 5: return [2 /*return*/, validator];
                     }
                 });
             });
@@ -26021,13 +26073,23 @@
             return true;
         };
         AppTable.prototype.confirmAndForward = function (event, row) {
-            row = row || this.editedRow;
-            if (!this.confirmEditCreate(event, row)) {
-                return false;
-            }
-            // Edit next row
-            this.editRowById(event, row.id + 1, { focusColumn: this.firstUserColumn });
-            return true;
+            return __awaiter(this, void 0, void 0, function () {
+                var done;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            row = row || this.editedRow;
+                            return [4 /*yield*/, this.confirmEditCreate(event, row)];
+                        case 1:
+                            done = _e.sent();
+                            if (done) {
+                                // Edit next row
+                                this.editRowById(event, row.id + 1, { focusColumn: this.firstUserColumn });
+                            }
+                            return [2 /*return*/, done];
+                    }
+                });
+            });
         };
         AppTable.prototype.editRowById = function (event, id, opts) {
             return __awaiter(this, void 0, void 0, function () {
@@ -26058,50 +26120,52 @@
          * @param row
          */
         AppTable.prototype.confirmEditCreate = function (event, row) {
-            var _this = this;
             var _a;
-            row = row || this.editedRow;
-            if (!row || !row.editing)
-                return true; // no row to confirm
-            // Stop event
-            event === null || event === void 0 ? void 0 : event.stopPropagation();
-            // Confirmation edition or creation
-            var confirmed = row.confirmEditCreate();
-            if (confirmed) {
-                // If edit finished, forget edited row
-                if (row === this.editedRow) {
-                    this.editedRow = undefined;
-                }
-                // Mark table as dirty (if row is dirty)
-                if ((_a = row.validator) === null || _a === void 0 ? void 0 : _a.dirty) {
-                    this.markAsDirty({ emitEvent: false /* because of resetError() */ });
-                }
-                // Clear error
-                this.resetError();
-                // Emit the confirm event
-                this.onConfirmEditCreateRow.next(row);
-                return true; // Continue
-            }
-            if (row.validator) {
-                // If pending: Wait end of validation, then loop
-                if (row.validator.pending) {
-                    AppFormUtils.waitWhilePending(row.validator).then(function () { return _this.confirmEditCreate(event, row); });
-                    return false;
-                }
-                // NOT confirmed = row has error
-                if (this.debug) {
-                    console.warn('[table] Cannot confirm row, because invalid');
-                    AppFormUtils.logFormErrors(row.validator, '[table] ');
-                }
-                // fix: mark all controls as touched to show errors
-                row.validator.markAllAsTouched();
-                // Compute row error, and propagate to table's error
-                if (this.propagateRowError) {
-                    var error = this.getRowError(row);
-                    this.setError(error);
-                }
-            }
-            return false;
+            return __awaiter(this, void 0, void 0, function () {
+                var done, error;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            row = row || this.editedRow;
+                            if (!row || !row.editing)
+                                return [2 /*return*/, true]; // no row to confirm
+                            // Stop event
+                            event === null || event === void 0 ? void 0 : event.stopPropagation();
+                            return [4 /*yield*/, row.confirmEditCreate()];
+                        case 1:
+                            done = _e.sent();
+                            if (done) {
+                                // If edit finished, forget edited row
+                                if (row === this.editedRow) {
+                                    this.editedRow = undefined;
+                                }
+                                // Mark table as dirty (if row is dirty)
+                                if ((_a = row.validator) === null || _a === void 0 ? void 0 : _a.dirty) {
+                                    this.markAsDirty({ emitEvent: false /* because of resetError() */ });
+                                }
+                                // Clear error
+                                this.resetError();
+                                // Emit the confirm event
+                                this.onConfirmEditCreateRow.next(row);
+                            }
+                            else if (row.validator) {
+                                // NOT confirmed = row has error
+                                if (this.debug) {
+                                    console.warn('[table] Cannot confirm row, because invalid');
+                                    AppFormUtils.logFormErrors(row.validator, '[table] ');
+                                }
+                                // fix: mark all controls as touched to show errors
+                                row.validator.markAllAsTouched();
+                                // Compute row error, and propagate to table's error
+                                if (this.propagateRowError) {
+                                    error = this.getRowError(row);
+                                    this.setError(error);
+                                }
+                            }
+                            return [2 /*return*/, done];
+                    }
+                });
+            });
         };
         AppTable.prototype.cancelOrDelete = function (event, row, opts) {
             // Delete new row
@@ -26961,13 +27025,16 @@
         };
         AppTable.prototype.addRowToTable = function (insertAt) {
             return __awaiter(this, void 0, void 0, function () {
+                var done;
                 return __generator(this, function (_e) {
                     switch (_e.label) {
                         case 0:
                             this.focusFirstColumn = true;
-                            return [4 /*yield*/, this._dataSource.asyncCreateNew(insertAt)];
+                            return [4 /*yield*/, this._dataSource.createNew(insertAt)];
                         case 1:
-                            _e.sent();
+                            done = _e.sent();
+                            if (!done)
+                                return [2 /*return*/, undefined];
                             this.editedRow = this._dataSource.getRow(-1);
                             // Emit start editing event
                             this.onStartEditingRow.emit(this.editedRow);
@@ -27109,54 +27176,74 @@
             }
         };
         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
-            this._dataSource.cancelOrDelete(row);
-            this.onCancelOrDeleteRow.next(row);
-            this.resetError();
-            this.totalRowCount--;
-            this.visibleRowCount--;
+            return __awaiter(this, void 0, void 0, function () {
+                var done;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            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
+                            return [4 /*yield*/, this._dataSource.cancelOrDelete(row)];
+                        case 1:
+                            done = _e.sent();
+                            if (done) {
+                                this.onCancelOrDeleteRow.next(row);
+                                this.resetError();
+                                this.totalRowCount--;
+                                this.visibleRowCount--;
+                            }
+                            return [2 /*return*/, done];
+                    }
+                });
+            });
         };
         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
+                return Promise.resolve(false); // SKip
             event === null || event === void 0 ? void 0 : event.preventDefault();
-            this.deleteRow(null, row, opts);
+            return this.deleteRow(null, row, opts);
         };
         AppTable.prototype.cancelExistingRow = function (event, row, opts) {
-            var _this = this;
             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)) {
-                event.stopPropagation();
-                this.canCancelRows([row], opts)
-                    .then(function (confirm) {
-                    // If confirmed, loop
-                    if (confirm)
-                        _this.cancelExistingRow(event, row, { interactive: false });
+            return __awaiter(this, void 0, void 0, function () {
+                var confirmed, confirm, keepEditing;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            // 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');
+                            confirmed = (!opts || opts.interactive !== false);
+                            if (!(!confirmed && ((_a = row.validator) === null || _a === void 0 ? void 0 : _a.dirty) && (this.confirmBeforeCancel || this.onBeforeCancelRows.observers.length > 0))) return [3 /*break*/, 2];
+                            event.stopPropagation();
+                            return [4 /*yield*/, this.canCancelRows([row], opts)];
+                        case 1:
+                            confirm = _e.sent();
+                            // If not confirmed: stop
+                            if (!confirm)
+                                return [2 /*return*/, false];
+                            _e.label = 2;
+                        case 2:
+                            keepEditing = row.editing && (!opts || opts.keepEditing !== false);
+                            this.editedRow = undefined; // unselect row
+                            this._dataSource.cancelOrDelete(row);
+                            this.onCancelOrDeleteRow.next(row);
+                            // Mark row as pristine
+                            this.checkIfRowPristine(row);
+                            // Restore editing state
+                            if (keepEditing) {
+                                this.editRow(undefined, row);
+                            }
+                            return [2 /*return*/, true];
+                    }
                 });
-                return;
-            }
-            var keepEditing = row.editing && (!opts || opts.keepEditing !== false);
-            this.editedRow = undefined; // unselect row
-            this._dataSource.cancelOrDelete(row);
-            this.onCancelOrDeleteRow.next(row);
-            // Mark row as pristine
-            this.checkIfRowPristine(row);
-            // Restore editing state
-            if (keepEditing) {
-                this.editRow(undefined, row);
-            }
+            });
         };
         AppTable.prototype.checkIfRowPristine = function (row, opts) {
             var _a, _b;