@sumaris-net/ngx-components 1.19.3 → 1.20.0-rc3

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

@@ -3363,7 +3363,7 @@
         function SharedValidators() {
         }
         SharedValidators.getDoubleRegexp = function (maxDecimals) {
-            if (isNil(maxDecimals))
+            if (isNil(maxDecimals) || maxDecimals === -1)
                 return this._REGEXP_CACHE.DOUBLE_BY_MAX_DECIMALS.NO_LIMIT;
             if (maxDecimals < 0)
                 throw new Error("Invalid maxDecimals value: " + maxDecimals);
@@ -10919,6 +10919,10 @@
             return isNotNil(obj.__typename) && (typeof obj.fromObject === 'function') && (typeof obj.asObject === 'function');
         };
         // Check that the object has a NOT nil attribute (ID by default)
+        EntityUtils.isNotEntity = function (obj) {
+            return isNil(obj.__typename) || (typeof obj.fromObject !== 'function') || (typeof obj.asObject !== 'function');
+        };
+        // Check that the object has a NOT nil attribute (ID by default)
         EntityUtils.isNotEmpty = function (obj, checkedAttribute) {
             return !!obj && obj[checkedAttribute] !== null && obj[checkedAttribute] !== undefined;
         };
@@ -24221,6 +24225,7 @@
                         ionicCache.CacheModule,
                         i3$2.IonicStorageModule,
                         ngxJdenticon.NgxJdenticonModule,
+                        i1$2.TranslateModule.forChild(),
                         // Sub modules
                         AppGraphQLModule,
                         AppMenuModule
@@ -24906,11 +24911,6 @@
         return AppTableUtils;
     }());
 
-    var AppTableDataSourceOptions = /** @class */ (function () {
-        function AppTableDataSourceOptions() {
-        }
-        return AppTableDataSourceOptions;
-    }());
     // @dynamic
     // eslint-disable-next-line @angular-eslint/directive-class-suffix
     var EntitiesTableDataSource = /** @class */ (function (_super_1) {
@@ -24920,40 +24920,29 @@
          *
          * @param dataService A service to load and save data
          * @param dataType Type of data contained by the Table. If not specified, then `data` with at least one element must be specified.
-         * @param environment
          * @param validatorService Service that create instances of the FormGroup used to validate row fields.
          * @param config Additional configuration for table.
          */
         function EntitiesTableDataSource(dataType, dataService, validatorService, config) {
-            var _this = _super_1.call(this, [], dataType, validatorService, config) || this;
+            var _this = _super_1.call(this, [], dataType, validatorService, Object.assign({ dataServiceOptions: {}, debug: config && config.suppressErrors === false, keepOriginalDataAfterConfirm: false }, config)) || this;
             _this.dataService = dataService;
             _this._creating = false;
             _this._saving = false;
-            _this._useValidator = false;
             _this._stopWatching$ = new rxjs.Subject();
             _this._editingRowCount = 0;
             _this._fetchMoreFn = null;
             _this.loadingSubject = new rxjs.BehaviorSubject(undefined);
-            _this._options = Object.assign({ dataServiceOptions: {}, debug: config && config.suppressErrors === false, keepOriginalDataAfterConfirm: false }, config);
-            _this._useValidator = isNotNil(validatorService);
             _this._logTypeName = removeEnd((new dataType()).__typename || 'UnknownVO', 'VO');
             // For DEV ONLY
-            _this._debug = _this._options.debug === true;
+            _this._debug = _this.config.debug === true;
             return _this;
         }
         Object.defineProperty(EntitiesTableDataSource.prototype, "serviceOptions", {
             get: function () {
-                return this._options.dataServiceOptions;
+                return this.config.dataServiceOptions;
             },
             set: function (value) {
-                this._options.dataServiceOptions = value;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(EntitiesTableDataSource.prototype, "options", {
-            get: function () {
-                return this._options;
+                this.config.dataServiceOptions = value;
             },
             enumerable: false,
             configurable: true
@@ -24972,12 +24961,11 @@
             enumerable: false,
             configurable: true
         });
-        EntitiesTableDataSource.prototype.ngOnDestroy = function () {
+        EntitiesTableDataSource.prototype.disconnect = function (collectionViewer) {
+            _super_1.prototype.disconnect.call(this, collectionViewer);
             this._stopWatching$.next();
             this._stopWatching$.complete();
-            this._stopWatching$.unsubscribe();
             this.loadingSubject.complete();
-            this.loadingSubject.unsubscribe();
         };
         EntitiesTableDataSource.prototype.watchAll = function (offset, size, sortBy, sortDirection, filter) {
             var _this = this;
@@ -25004,7 +24992,7 @@
         };
         EntitiesTableDataSource.prototype.save = function () {
             return __awaiter(this, void 0, void 0, function () {
-                var onlyDirtyRows, rows, invalidRows, data, dataToSave_1, error_1;
+                var onlyDirtyRows, rows, confirmed, data, dataToSave_1, error_1;
                 var _this = this;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
@@ -25023,32 +25011,33 @@
                             onlyDirtyRows = toBoolean(this.serviceOptions.saveOnlyDirtyRows, false);
                             _a.label = 1;
                         case 1:
-                            _a.trys.push([1, 4, 5, 6]);
+                            _a.trys.push([1, 5, 6, 7]);
                             if (this._debug)
                                 console.debug("[table-datasource] Saving " + this._logTypeName + " rows... {onlyDirty: " + onlyDirtyRows + "}");
                             return [4 /*yield*/, this.getRows()];
                         case 2:
                             rows = _a.sent();
-                            invalidRows = rows.filter(function (row) { return row.editing && !row.confirmEditCreate(); });
+                            return [4 /*yield*/, this.confirmRows(rows)];
+                        case 3:
+                            confirmed = _a.sent();
                             // Cannot finish some rows: error
-                            if (invalidRows.length) {
+                            if (!confirmed) {
                                 // log errors
                                 if (this._debug)
-                                    invalidRows.forEach(function (row) { return AppTableUtils.logRowErrors(row, "[table-datasource] " + _this._logTypeName + " row #" + row.id); });
+                                    this.getEditingRows(rows).forEach(function (row) { return AppTableUtils.logRowErrors(row, "[table-datasource] " + _this._logTypeName + " row #" + row.id); });
                                 // Stop with an error
                                 throw { code: ErrorCodes.TABLE_INVALID_ROW_ERROR, message: 'ERROR.TABLE_INVALID_ROW_ERROR' };
                             }
                             this._editingRowCount = 0;
                             data = void 0;
-                            if (this._useValidator) {
+                            if (!!this.validatorService) {
                                 dataToSave_1 = [];
                                 data = rows.map(function (row) {
-                                    var currentData = new _this.dataConstructor();
-                                    currentData.fromObject(row.currentData);
+                                    var entity = _this.toEntity(row.currentData);
                                     // Filter to keep only dirty row
                                     if (onlyDirtyRows && row.validator.dirty)
-                                        dataToSave_1.push(currentData);
-                                    return currentData;
+                                        dataToSave_1.push(entity);
+                                    return entity;
                                 });
                                 if (!onlyDirtyRows)
                                     dataToSave_1 = data;
@@ -25068,46 +25057,65 @@
                             if (this._debug)
                                 console.debug("[table-datasource] Asking service to save this " + this._logTypeName + " data:", dataToSave_1);
                             return [4 /*yield*/, this.dataService.saveAll(dataToSave_1, this.serviceOptions)];
-                        case 3:
+                        case 4:
                             _a.sent();
                             if (this._debug)
                                 console.debug("[table-datasource] Saving " + this._logTypeName + " data [OK]");
                             // LP 23/03/2021: update datasource is necessary but can be changed to a refetch() on QueryRef (must be created and registered in GraphqlService.watchQuery)
                             this.updateDatasource(data, { emitEvent: false });
                             return [2 /*return*/, true];
-                        case 4:
+                        case 5:
                             error_1 = _a.sent();
                             if (this._debug)
                                 console.error('[table-datasource] Error while saving: ' + error_1 && error_1.message || error_1);
                             throw error_1;
-                        case 5:
+                        case 6:
                             this._saving = false;
                             this.markAsLoaded();
                             return [7 /*endfinally*/];
-                        case 6: return [2 /*return*/];
+                        case 7: return [2 /*return*/];
                     }
                 });
             });
         };
-        EntitiesTableDataSource.prototype.updateDatasource = function (data, opts) {
-            if (this._debug)
-                console.debug("[table-datasource] Updating datasource with data:", data);
-            _super_1.prototype.updateDatasource.call(this, data, opts);
-            if (!opts || opts.emitEvent !== false) {
-                this.markAsLoaded();
+        EntitiesTableDataSource.prototype.getDataFromRows = function (rows, options) {
+            var _this = this;
+            if (options === void 0) { options = { originalData: false, toEntity: false }; }
+            if (options.toEntity) {
+                return _super_1.prototype.getDataFromRows.call(this, rows, options)
+                    .map(function (data) { return _this.toEntity(data); });
             }
+            return _super_1.prototype.getDataFromRows.call(this, rows, options);
         };
-        // Overwrite default signature
-        EntitiesTableDataSource.prototype.createNew = function (insertAt) {
-            this.asyncCreateNew(insertAt);
-        };
-        EntitiesTableDataSource.prototype.connect = function (collectionViewer) {
-            // DEBUG console.debug("[entities-datasource] connect");
-            return _super_1.prototype.connect.call(this, collectionViewer);
+        EntitiesTableDataSource.prototype.toEntity = function (data) {
+            if (EntityUtils.isNotEntity(data)) {
+                var entity = new this.dataConstructor();
+                entity.fromObject(data);
+                return entity;
+            }
+            return data;
         };
-        EntitiesTableDataSource.prototype.disconnect = function (collectionViewer) {
-            _super_1.prototype.disconnect.call(this, collectionViewer);
-            this._stopWatching$.next();
+        EntitiesTableDataSource.prototype.updateDatasource = function (data, opts) {
+            if (opts === void 0) { opts = { emitEvent: true }; }
+            var _super = Object.create(null, {
+                updateDatasource: { get: function () { return _super_1.prototype.updateDatasource; } }
+            });
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (this._debug)
+                                console.debug("[table-datasource] Updating datasource with data:", data);
+                            return [4 /*yield*/, _super.updateDatasource.call(this, data, opts)];
+                        case 1:
+                            _a.sent();
+                            if (opts.emitEvent) {
+                                this.markAsLoaded();
+                            }
+                            return [2 /*return*/];
+                    }
+                });
+            });
         };
         EntitiesTableDataSource.prototype.waitIdle = function (debounceTimeMs) {
             return firstFalsePromise(this.loadingSubject
@@ -25116,34 +25124,88 @@
             ));
         };
         EntitiesTableDataSource.prototype.confirmCreate = function (row) {
-            if (!_super_1.prototype.confirmCreate.call(this, row))
-                return false;
-            if (row.editing && row.validator) {
-                console.warn('[table-datasource] Row still has {editing: true} after confirmCreate()! Force editing to false');
-                row.validator.disable({ onlySelf: true, emitEvent: false });
-            }
-            return true;
+            var _super = Object.create(null, {
+                confirmCreate: { get: function () { return _super_1.prototype.confirmCreate; } }
+            });
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, _super.confirmCreate.call(this, row)];
+                        case 1:
+                            if (!(_a.sent()))
+                                return [2 /*return*/, false];
+                            if (row.editing && row.validator) {
+                                console.warn('[table-datasource] Row still has {editing: true} after confirmCreate()! Force editing to false');
+                                row.validator.disable({ onlySelf: true, emitEvent: false });
+                            }
+                            return [2 /*return*/, true];
+                    }
+                });
+            });
         };
         EntitiesTableDataSource.prototype.confirmEdit = function (row) {
-            if (!_super_1.prototype.confirmEdit.call(this, row))
-                return false;
-            if (row.editing && row.validator) {
-                console.warn('[table-datasource] Row still has {editing: true} after confirmCreate()! Force editing to false');
-                row.validator.disable({ onlySelf: true, emitEvent: false });
-            }
-            return true;
+            var _super = Object.create(null, {
+                confirmEdit: { get: function () { return _super_1.prototype.confirmEdit; } }
+            });
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, _super.confirmEdit.call(this, row)];
+                        case 1:
+                            if (!(_a.sent()))
+                                return [2 /*return*/, false];
+                            if (row.editing && row.validator) {
+                                console.warn('[table-datasource] Row still has {editing: true} after confirmCreate()! Force editing to false');
+                                row.validator.disable({ onlySelf: true, emitEvent: false });
+                            }
+                            return [2 /*return*/, true];
+                    }
+                });
+            });
         };
         EntitiesTableDataSource.prototype.startEdit = function (row) {
-            if (this._debug)
-                console.debug('[table-datasource] Start to edit row', row);
-            row.startEdit();
-            this._editingRowCount++;
+            var _super = Object.create(null, {
+                startEdit: { get: function () { return _super_1.prototype.startEdit; } }
+            });
+            return __awaiter(this, void 0, void 0, function () {
+                var done;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (row.editing)
+                                return [2 /*return*/]; // Already editing
+                            if (this._debug)
+                                console.debug('[table-datasource] Start to edit row', row);
+                            return [4 /*yield*/, _super.startEdit.call(this, row)];
+                        case 1:
+                            done = _a.sent();
+                            if (done)
+                                this._editingRowCount++;
+                            return [2 /*return*/, done];
+                    }
+                });
+            });
         };
-        EntitiesTableDataSource.prototype.cancelOrDelete = function (row) {
-            if (this._debug)
-                console.debug('[table-datasource] Cancelling or deleting row', row);
-            row.cancelOrDelete();
-            this._editingRowCount--;
+        EntitiesTableDataSource.prototype.cancel = function (row) {
+            var _super = Object.create(null, {
+                cancel: { get: function () { return _super_1.prototype.cancel; } }
+            });
+            return __awaiter(this, void 0, void 0, function () {
+                var done;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (this._debug)
+                                console.debug('[table-datasource] Cancelling row', row);
+                            return [4 /*yield*/, _super.cancel.call(this, row)];
+                        case 1:
+                            done = _a.sent();
+                            if (done)
+                                this._editingRowCount--;
+                            return [2 /*return*/, done];
+                    }
+                });
+            });
         };
         EntitiesTableDataSource.prototype.handleError = function (error, message) {
             var errorMsg = error && error.message || error;
@@ -25158,92 +25220,166 @@
             throw error;
         };
         EntitiesTableDataSource.prototype.delete = function (id) {
-            var _this = this;
-            // If new row: not need to propagate to the dataService
-            if (id === -1) {
-                return _super_1.prototype.delete.call(this, id);
-            }
-            var row = this.getRow(id);
-            if (!row) {
-                console.error("[table-datasource] Row to delete with id=" + id + " not found");
-                return;
-            }
-            this.loadingSubject.next(true);
-            this.dataService.deleteAll([row.currentData], this.serviceOptions)
-                .catch(function (err) { return _this.handleErrorPromise(err); })
-                .then(function () {
-                setTimeout(function () {
-                    // make sure row has been deleted (because GrapQHl cache remove can failed)
-                    var present = _this.getRow(id) === row;
-                    if (present)
-                        _super_1.prototype.delete.call(_this, id);
-                    _this.loadingSubject.next(false);
-                }, 300);
+            var _super = Object.create(null, {
+                delete: { get: function () { return _super_1.prototype.delete; } }
+            });
+            return __awaiter(this, void 0, void 0, function () {
+                var row, present, err_1;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            // If new row: not need to propagate to the dataService
+                            if (id === -1) {
+                                return [2 /*return*/, _super.delete.call(this, id)];
+                            }
+                            row = this.getRow(id);
+                            if (!row) {
+                                console.error("[table-datasource] Row to delete with id=" + id + " not found");
+                                return [2 /*return*/];
+                            }
+                            this.markAsLoading();
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, 6, 7, 8]);
+                            return [4 /*yield*/, this.dataService.deleteAll([row.currentData], this.serviceOptions)];
+                        case 2:
+                            _a.sent();
+                            // Make sure row has been deleted (because GrapQHl cache remove can failed)
+                            return [4 /*yield*/, sleep(300)];
+                        case 3:
+                            // Make sure row has been deleted (because GrapQHl cache remove can failed)
+                            _a.sent();
+                            present = this.getRow(id) === row;
+                            if (!present) return [3 /*break*/, 5];
+                            console.warn('[table-datasource] Force deletion of 1 row (Is service applying deletion to observable ?)');
+                            return [4 /*yield*/, _super.delete.call(this, id)];
+                        case 4:
+                            _a.sent();
+                            _a.label = 5;
+                        case 5: return [3 /*break*/, 8];
+                        case 6:
+                            err_1 = _a.sent();
+                            this.handleErrorPromise(err_1);
+                            return [3 /*break*/, 8];
+                        case 7:
+                            this.markAsLoaded();
+                            return [7 /*endfinally*/];
+                        case 8: return [2 /*return*/];
+                    }
+                });
             });
         };
         EntitiesTableDataSource.prototype.deleteAll = function (rows) {
-            var _this = this;
-            this.markAsLoading();
-            var data = rows.map(function (r) { return r.currentData; });
-            var rowsById = rows.reduce(function (res, row) {
-                res[row.id] = row;
-                return res;
-            }, {});
-            var self = this;
-            var selfDelete = _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 selfDelete.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 firstNotNilPromise(this.connect(null));
+            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_1;
+                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._options && this._options.onRowCreated)) return [3 /*break*/, 4];
-                            res = this._options.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_1 = _a.sent();
-                            console.error(err_1 && err_1.message || err_1, err_1);
-                            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];
                     }
                 });
             });
@@ -25266,19 +25402,19 @@
                 updateDatasource: { get: function () { return _super_1.prototype.updateDatasource; } }
             });
             return __awaiter(this, void 0, void 0, function () {
-                var res, existingData;
+                var fetchMoreFn, res, existingData;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
                             if (!this._fetchMoreFn)
-                                return [2 /*return*/, false]; // Avoid multiple call
+                                return [2 /*return*/, false];
                             if (this._editingRowCount > 0) {
                                 console.warn('Cannot fetch more because still editing row');
                                 return [2 /*return*/];
                             }
-                            // Fetch next page
-                            this._fetchMoreFn = null; // Avoid multiple call
-                            return [4 /*yield*/, this._fetchMoreFn()];
+                            fetchMoreFn = this._fetchMoreFn;
+                            this._fetchMoreFn = null;
+                            return [4 /*yield*/, fetchMoreFn()];
                         case 1:
                             res = _a.sent();
                             // Skip if empty (no more data)
@@ -25287,8 +25423,10 @@
                             return [4 /*yield*/, this.getData()];
                         case 2:
                             existingData = _a.sent();
-                            _super.updateDatasource.call(this, existingData.concat.apply(existingData, __spread(res.data)), opts);
-                            // Remember fetchMore
+                            return [4 /*yield*/, _super.updateDatasource.call(this, existingData.concat.apply(existingData, __spread(res.data)), opts)];
+                        case 3:
+                            _a.sent();
+                            // Store next fetchMore function
                             this._fetchMoreFn = res.fetchMore;
                             return [2 /*return*/, true];
                     }
@@ -25314,8 +25452,8 @@
     EntitiesTableDataSource.ctorParameters = function () { return [
         { type: Function },
         { type: undefined },
-        { type: ngxMaterialTable.ValidatorService },
-        { type: AppTableDataSourceOptions }
+        { type: undefined },
+        { type: undefined }
     ]; };
 
     var SETTINGS_DISPLAY_COLUMNS = 'displayColumns';
@@ -25806,7 +25944,6 @@
         };
         AppTable.prototype.ngOnDestroy = function () {
             var _this = this;
-            var _a;
             this._subscription.unsubscribe();
             // Unsubscribe column value changes
             Object.keys(this._cellValueChangesDefs).forEach(function (col) { return _this.stopCellValueChanges(col, true); });
@@ -25831,7 +25968,6 @@
             this.onError.unsubscribe();
             this._destroy$.next();
             this._destroy$.unsubscribe();
-            (_a = this._dataSource) === null || _a === void 0 ? void 0 : _a.ngOnDestroy();
         };
         AppTable.prototype.updateView = function (res, opts) {
             return __awaiter(this, void 0, void 0, function () {
@@ -25876,7 +26012,7 @@
                 this._dataSourceLoadingSubscription.unsubscribe();
                 this._subscription.remove(this._dataSourceLoadingSubscription);
             }
-            (_a = this._dataSource) === null || _a === void 0 ? void 0 : _a.ngOnDestroy();
+            (_a = this._dataSource) === null || _a === void 0 ? void 0 : _a.disconnect();
             this._dataSource = null;
         };
         AppTable.prototype.addColumnDef = function (column) {
@@ -25933,13 +26069,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 () {
@@ -25970,50 +26116,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
@@ -26062,6 +26210,7 @@
                             // Keep edited row id (should be done BEFORE confirmEditCreate() )
                             this.previouslyEditedRowId = opts.keepEditing ? ((((_a = this.editedRow) === null || _a === void 0 ? void 0 : _a.editing) ? this.editedRow.id : undefined) || ((_b = this.singleSelectedRow) === null || _b === void 0 ? void 0 : _b.id)) : undefined;
                             previouslyEditedData = opts.keepEditing ? (isNotNil(this.previouslyEditedRowId) && ((_c = this.editedRow) === null || _c === void 0 ? void 0 : _c.currentData) || ((_d = this.singleSelectedRow) === null || _d === void 0 ? void 0 : _d.currentData)) : undefined;
+                            // TODO: remove this, has it redundant with dataSource.confirmAllRows() called in dataSource.save()
                             if (!this.confirmEditCreate()) {
                                 throw { code: ErrorCodes.TABLE_INVALID_ROW_ERROR, message: 'ERROR.TABLE_INVALID_ROW_ERROR' };
                             }
@@ -26872,13 +27021,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);
@@ -27020,54 +27172,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;
@@ -27076,7 +27248,7 @@
                 return __generator(this, function (_e) {
                     switch (_e.label) {
                         case 0:
-                            markRowAsPristine = ((_a = this.dataSource) === null || _a === void 0 ? void 0 : _a.options.keepOriginalDataAfterConfirm) === true;
+                            markRowAsPristine = ((_a = this.dataSource) === null || _a === void 0 ? void 0 : _a.config.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];
@@ -28819,7 +28991,7 @@
         { type: Function },
         { type: InMemoryEntitiesService },
         { type: ngxMaterialTable.ValidatorService },
-        { type: AppTableDataSourceOptions },
+        { type: undefined },
         { type: undefined }
     ]; };
     AppInMemoryTable.propDecorators = {
@@ -30080,7 +30252,11 @@
                 switch (authTokenType) {
                     case "basic":
                         _this.setShowColumn('pubkey', false, { emitEvent: false });
+                        _this.setShowColumn('username', true, { emitEvent: false });
+                        _this.setShowColumn('usernameExtranet', true, { emitEvent: false });
+                        break;
                     case "basic-and-token":
+                        _this.setShowColumn('pubkey', true, { emitEvent: false });
                         _this.setShowColumn('username', true, { emitEvent: false });
                         _this.setShowColumn('usernameExtranet', true, { emitEvent: false });
                         break;
@@ -31834,7 +32010,6 @@
     exports.AppTabEditor = AppTabEditor;
     exports.AppTabEditorOptions = AppTabEditorOptions;
     exports.AppTable = AppTable;
-    exports.AppTableDataSourceOptions = AppTableDataSourceOptions;
     exports.AppTableUtils = AppTableUtils;
     exports.AppValidatorService = AppValidatorService;
     exports.AppendToInputDirective = AppendToInputDirective;