@sumaris-net/ngx-components 18.13.0 → 18.14.0

package/src/app/core/table/async-table.class.ts

@@ -0,0 +1,2021 @@
+import { AfterViewInit, ChangeDetectorRef, Directive, EventEmitter, Injector, Input, OnDestroy, OnInit, Output, ViewChild } from '@angular/core';
+import { MatPaginator } from '@angular/material/paginator';
+import { MatSort, MatSortable, SortDirection } from '@angular/material/sort';
+import { MatTable } from '@angular/material/table';
+import { BehaviorSubject, EMPTY, merge, Observable, of, Subject, Subscription } from 'rxjs';
+import { catchError, debounceTime, distinctUntilChanged, filter, first, mergeMap, startWith, switchMap, takeUntil, tap } from 'rxjs/operators';
+import { SelectionModel } from '@angular/cdk/collections';
+import { EntityUtils, IEntity } from '../services/model/entity.model';
+import { AlertController, ModalController, NavController, ToastController } from '@ionic/angular';
+import { ActivatedRoute, Router } from '@angular/router';
+import { ColumnItem, TableSelectColumnsComponent } from './table-select-columns.component';
+import { Location } from '@angular/common';
+import { ErrorCodes } from '../services/errors';
+import { AppFormUtils, CanSave, IAppForm, OnReady } from '../form/form.utils';
+import { LocalSettingsService } from '../services/local-settings.service';
+import { TranslateService } from '@ngx-translate/core';
+import {
+  MatAutocompleteConfigHolder,
+  MatAutocompleteFieldAddOptions,
+  MatAutocompleteFieldConfig,
+} from '../../shared/material/autocomplete/material.autocomplete.config';
+import { CompletableEvent, createPromiseEventEmitter, emitPromiseEvent } from '../../shared/events';
+import {
+  changeCaseToUnderscore,
+  getPropertyByPath,
+  isEmptyArray,
+  isNil,
+  isNotEmptyArray,
+  isNotNil,
+  setPropertyByPath,
+  toBoolean,
+} from '../../shared/functions';
+import { waitFor, waitForFalse, WaitForOptions, waitForTrue } from '../../shared/observables';
+import { ShowToastOptions, Toasts } from '../../shared/toast/toasts';
+import { Alerts } from '../../shared/alerts';
+import { CdkColumnDef } from '@angular/cdk/table';
+import { LoadResult } from '../../shared/services/entity-service.class';
+import { FormErrorTranslateOptions, FormErrorTranslator, IFormPathTranslator } from '../../shared/validator/form-error-adapter.class';
+import {
+  CellValueChangeListener,
+  DEFAULT_PAGE_SIZE,
+  DEFAULT_PAGE_SIZE_OPTIONS,
+  DEFAULT_REQUIRED_COLUMNS,
+  RESERVED_END_COLUMNS,
+  RESERVED_START_COLUMNS,
+  SaveActionType,
+  SETTINGS_DISPLAY_COLUMNS,
+  SETTINGS_PAGE_SIZE,
+  SETTINGS_SORTED_COLUMN,
+} from './table.model';
+import { AsyncTableElement } from '@e-is/ngx-material-table';
+import { EntitiesAsyncTableDataSource } from './entities-async-table-datasource.class';
+import { AppTableUtils } from './table.utils';
+
+// @dynamic
+// noinspection DuplicatedCode
+@Directive()
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export abstract class AppAsyncTable<T extends IEntity<T, ID>, F = any, ID = number>
+  implements OnInit, OnDestroy, AfterViewInit, IAppForm, CanSave, IFormPathTranslator
+{
+  private _initialized = false;
+  private _openingRow = false;
+  private _subscription = new Subscription();
+  private _dataSourceLoadingSubscription: Subscription;
+
+  private _cellValueChangesDefs: {
+    [key: string]: CellValueChangeListener;
+  } = {};
+
+  protected _enabled = true;
+  protected _autocompleteConfigHolder: MatAutocompleteConfigHolder;
+  protected allowRowDetail = true;
+  protected readonly cd: ChangeDetectorRef;
+  protected route: ActivatedRoute;
+  protected router: Router;
+  protected navController: NavController;
+  protected location: Location;
+  protected settings: LocalSettingsService;
+  protected translate: TranslateService;
+  protected modalCtrl: ModalController;
+  protected alertCtrl: AlertController;
+  protected toastController: ToastController;
+  protected previouslyEditedRowId: number;
+  protected formErrorAdapter: FormErrorTranslator;
+  protected readonly destroySubject = new Subject<void>();
+
+  excludesColumns: string[] = [];
+  displayedColumns: string[];
+  totalRowCount: number | null = null;
+  visibleRowCount: number;
+  errorTranslateOptions: FormErrorTranslateOptions;
+
+  readonly readySubject = new BehaviorSubject<boolean>(false);
+  readonly loadingSubject = new BehaviorSubject<boolean>(true);
+  readonly savingSubject = new BehaviorSubject<boolean>(false);
+  readonly touchedSubject = new BehaviorSubject<boolean>(false);
+  readonly dirtySubject = new BehaviorSubject<boolean>(false);
+  readonly errorSubject = new BehaviorSubject<string>(undefined);
+
+  get error(): string {
+    return this.errorSubject.value;
+  }
+
+  set error(error: string) {
+    this.setError(error);
+  }
+
+  selection = new SelectionModel<AsyncTableElement<T>>(true, []);
+  permanentSelection: SelectionModel<T> = null;
+  permanentSelectionChangedPrevented = false;
+  autocompleteFields: { [key: string]: MatAutocompleteFieldConfig };
+  readonly mobile: boolean;
+
+  // Table options
+  @Input() settingsId: string;
+  @Input() debug: boolean;
+  @Input() i18nColumnPrefix = 'COMMON.';
+  @Input() i18nColumnSuffix: string;
+  @Input() autoLoad = true;
+  @Input() readOnly: boolean;
+  @Input() inlineEdition: boolean;
+  @Input() focusFirstColumn = false;
+  @Input() confirmBeforeDelete = false;
+  @Input() confirmBeforeCancel = false;
+  @Input() undoableDeletion = false;
+  @Input() saveBeforeDelete: boolean;
+  @Input() keepEditedRowOnSave: boolean;
+  @Input() saveBeforeSort: boolean;
+  @Input() saveBeforeFilter: boolean;
+  @Input() propagateRowError = false;
+  @Input() permanentSelectionAllowed = false; // Allow keep selected rows over page change or sort change
+  @Input() openRowThrottleTime = 800; // Prevent double click - see issue sumaris-app#864
+
+  @Input() defaultSortBy: string;
+  @Input() defaultSortDirection: SortDirection;
+  @Input() defaultPageSize = DEFAULT_PAGE_SIZE;
+  @Input() defaultPageSizeOptions = DEFAULT_PAGE_SIZE_OPTIONS;
+
+  // Focus manager
+  @Input() focusColumn: string;
+
+  get firstUserColumn(): string {
+    return this.displayedColumns[RESERVED_START_COLUMNS.length];
+  }
+
+  get lastUserColumn(): string {
+    return this.displayedColumns[this.displayedColumns.length - RESERVED_END_COLUMNS.length - 1];
+  }
+
+  @Input() set dataSource(value: EntitiesAsyncTableDataSource<T, F, ID>) {
+    this.setDatasource(value);
+  }
+
+  get dataSource(): EntitiesAsyncTableDataSource<T, F, ID> {
+    return this._dataSource;
+  }
+
+  @Input() set filter(value: F) {
+    this.setFilter(value);
+  }
+
+  get filter(): F {
+    return this._filter;
+  }
+
+  get empty(): boolean {
+    return this.loading || this.totalRowCount === 0;
+  }
+
+  get selectedEntities(): T[] {
+    return this.permanentSelection?.selected || AppTableUtils.getEntities(this.selection.selected);
+  }
+
+  @Output() onRefresh = new EventEmitter<any>();
+  @Output() onClickRow = new EventEmitter<AsyncTableElement<T>>();
+  @Output() onOpenRow = new EventEmitter<AsyncTableElement<T>>();
+  @Output() onNewRow = new EventEmitter<any>();
+  @Output() onStartEditingRow = new EventEmitter<AsyncTableElement<T>>();
+  @Output() onConfirmEditCreateRow = new EventEmitter<AsyncTableElement<T>>();
+  @Output() onCancelOrDeleteRow = new EventEmitter<AsyncTableElement<T>>();
+  @Output() onBeforeDeleteRows = createPromiseEventEmitter<boolean, { rows: AsyncTableElement<T>[] }>();
+  @Output() onBeforeCancelRows = createPromiseEventEmitter<boolean, { rows: AsyncTableElement<T>[] }>();
+  @Output() onBeforeSave = createPromiseEventEmitter<{ confirmed: boolean; save: boolean }, { action: SaveActionType; valid: boolean }>();
+  @Output() onAfterDeletedRows = new EventEmitter<AsyncTableElement<T>[]>();
+  @Output() onSort = new EventEmitter<any>();
+  @Output() onDirty = new EventEmitter<boolean>();
+  @Output() onError = new EventEmitter<string>();
+
+  get dirty(): boolean {
+    return this.dirtySubject.value;
+  }
+
+  get valid(): boolean {
+    return this.dataSource.getEditingRows().every((row) => (row.editing ? row.valid : true));
+  }
+
+  get invalid(): boolean {
+    return this.dataSource.getEditingRows().some((row) => (row.editing ? row.invalid : false));
+  }
+
+  get pending(): boolean {
+    return this.dataSource.getEditingRows().some((row) => (row.editing ? row.pending : false));
+  }
+
+  get touched(): boolean {
+    return this.touchedSubject.value;
+  }
+
+  get untouched(): boolean {
+    return !this.touchedSubject.value;
+  }
+
+  disable(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {
+    if (this.sort) this.sort.disabled = true;
+    this._enabled = false;
+    if (!opts || opts.emitEvent !== false) this.markForCheck();
+  }
+
+  enable(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {
+    if (this.sort) this.sort.disabled = false;
+    this._enabled = true;
+    if (!opts || opts.emitEvent !== false) this.markForCheck();
+  }
+
+  get enabled(): boolean {
+    return this._enabled;
+  }
+
+  // FIXME: need to hidden buttons (in HTML), etc. when disabled
+  @Input() set disabled(value: boolean) {
+    if (value !== !this._enabled) {
+      if (value) this.disable({ emitEvent: false });
+      else this.enable({ emitEvent: false });
+    }
+  }
+
+  get disabled(): boolean {
+    return !this._enabled;
+  }
+
+  markAsDirty(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {
+    if (!this.dirtySubject.closed && this.dirtySubject.value !== true) {
+      this.dirtySubject.next(true);
+      if (!opts || opts.emitEvent !== false) {
+        this.markForCheck();
+      }
+    }
+  }
+
+  markAsPristine(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {
+    if (!this.dirtySubject.closed && this.dirtySubject.value !== false) {
+      this.dirtySubject.next(false);
+      if (!opts || opts.emitEvent !== false) {
+        this.markForCheck();
+      }
+    }
+  }
+
+  async markAsUntouched(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {
+    let needEmitEvent = false;
+    if (this.touchedSubject.value) {
+      this.touchedSubject.next(false);
+      needEmitEvent = true;
+    }
+    if (this.dirty) {
+      for (const row of this.dataSource.getEditingRows()) {
+        // Cancel the current editing row only if editing and if it was not previously saved
+        if (row.id === -1) {
+          await this.dataSource.delete(-1);
+        } else if (row.editing) {
+          await this.dataSource.cancel(row);
+        }
+
+        // Check if row as pristine
+        await this.checkIfRowPristine(row, { onlySelf: true /* avoid propagation to table - done just after */ });
+      }
+
+      // Check if the table is pristine
+      await this.checkIfPristine({ emitEvent: false /*will be done just after*/ });
+
+      needEmitEvent = true;
+    }
+    this.previouslyEditedRowId = undefined;
+    if (needEmitEvent && (!opts || opts.emitEvent !== false)) this.markForCheck();
+  }
+
+  /**
+   * @deprecated prefer to use markAllAsTouched()
+   * @param opts
+   */
+  markAsTouched(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {
+    console.warn('TODO: Replace this call by markAllAsTouched() - because of changes in ngx-components >= 0.16.0');
+    if (this.dataSource.hasSomeEditingRow()) {
+      this.dataSource.getEditingRows().forEach((row) => row.validator?.markAllAsTouched());
+      if (!opts || opts.emitEvent !== false) {
+        this.markForCheck();
+      }
+    }
+  }
+
+  markAllAsTouched(opts?: { emitEvent?: boolean }) {
+    if (!this.touchedSubject.closed && this.touchedSubject.value !== true) {
+      this.touchedSubject.next(true);
+      if (!opts || opts.emitEvent !== false) this.markForCheck();
+    }
+    this.dataSource.getEditingRows().forEach((row) => row.validator?.markAllAsTouched());
+  }
+
+  markAsSaving(opts?: { emitEvent?: boolean }) {
+    if (!this.savingSubject.closed && this.savingSubject.value !== true) {
+      this.focusColumn = undefined; // unselect focus column
+      this.savingSubject.next(true);
+      if (!opts || opts.emitEvent !== false) this.markForCheck();
+    }
+  }
+
+  markAsSaved(opts?: { emitEvent?: boolean }) {
+    if (!this.savingSubject.closed && this.savingSubject.value !== false) {
+      this.savingSubject.next(false);
+      if (!opts || opts.emitEvent !== false) this.markForCheck();
+    }
+  }
+
+  markAsLoading(opts?: { emitEvent?: boolean }) {
+    this.setLoading(true, opts);
+  }
+
+  markAsLoaded(opts?: { emitEvent?: boolean }) {
+    this.setLoading(false, opts);
+  }
+
+  markAsReady(opts?: { emitEvent?: boolean }) {
+    if (!this.readySubject.closed && this.readySubject.value !== true) {
+      this.readySubject.next(true);
+
+      // If subclasses implements OnReady
+      if (typeof this['ngOnReady'] === 'function') {
+        (this as any as OnReady).ngOnReady();
+      }
+    }
+  }
+
+  get loading(): boolean {
+    return this.loadingSubject.value;
+  }
+
+  get loaded(): boolean {
+    return !this.loadingSubject.value;
+  }
+
+  enableSort() {
+    if (this.sort) this.sort.disabled = false;
+  }
+
+  disableSort() {
+    if (this.sort) this.sort.disabled = true;
+  }
+
+  set pageSize(value: number) {
+    this.defaultPageSize = value;
+    if (this.paginator) {
+      this.paginator.pageSize = value;
+    }
+  }
+
+  get pageSize(): number {
+    return (this.paginator && this.paginator.pageSize) || this.defaultPageSize || DEFAULT_PAGE_SIZE;
+  }
+
+  get pageOffset(): number {
+    return (this.paginator && this.paginator.pageIndex * this.paginator.pageSize) || 0;
+  }
+
+  get sortActive(): string {
+    return this.sort && this.sort.active;
+  }
+
+  set sortActive(sortBy: string) {
+    if (this.sort) {
+      this.sort.active = sortBy;
+    } else {
+      this.defaultSortBy = sortBy;
+    }
+  }
+
+  get sortDirection(): SortDirection {
+    return (this.sort && this.sort.direction && (this.sort.direction === 'desc' ? 'desc' : 'asc')) || undefined;
+  }
+
+  set sortDirection(value: SortDirection) {
+    if (this.sort) {
+      this.sort.direction = value;
+    } else {
+      this.defaultSortDirection = value;
+    }
+  }
+
+  private _paginator: MatPaginator | null = null;
+
+  @Input() set paginator(value: MatPaginator) {
+    this._paginator = value;
+  }
+
+  get paginator(): MatPaginator {
+    return this._paginator || this.childPaginator;
+  }
+
+  get destroyed(): boolean {
+    return this.destroySubject?.closed !== false;
+  }
+
+  @ViewChild(MatTable, { static: false }) table: MatTable<T>;
+  @ViewChild(MatPaginator, { static: false }) childPaginator: MatPaginator;
+  @ViewChild(MatSort, { static: false }) sort: MatSort;
+
+  protected constructor(
+    injector: Injector,
+    protected columns: string[],
+    protected _dataSource?: EntitiesAsyncTableDataSource<T, F, ID>,
+    private _filter?: F
+  ) {
+    this.cd = injector.get(ChangeDetectorRef);
+    this.route = injector.get(ActivatedRoute);
+    this.router = injector.get(Router);
+    this.navController = injector.get(NavController);
+    this.location = injector.get(Location);
+    this.settings = injector.get(LocalSettingsService);
+    this.translate = injector.get(TranslateService);
+    this.modalCtrl = injector.get(ModalController);
+    this.alertCtrl = injector.get(AlertController);
+    this.toastController = injector.get(ToastController);
+    this.formErrorAdapter = injector.get(FormErrorTranslator);
+    this.mobile = this.settings.mobile;
+
+    // Autocomplete fields
+    this._autocompleteConfigHolder = new MatAutocompleteConfigHolder({
+      getUserAttributes: (a, b) => this.settings.getFieldDisplayAttributes(a, b),
+    });
+    this.autocompleteFields = this._autocompleteConfigHolder.fields;
+  }
+
+  ngOnInit() {
+    if (this._initialized) return; // Init only once
+    this._initialized = true;
+
+    // Set defaults
+    this.readOnly = toBoolean(this.readOnly, this.dataSource?.config.readOnly || false); // read/write by default
+    this.inlineEdition = !this.readOnly && toBoolean(this.inlineEdition, false); // force to false when readonly
+    this.saveBeforeDelete = toBoolean(this.saveBeforeDelete, !this.readOnly); // force to false when readonly
+    this.saveBeforeSort = toBoolean(this.saveBeforeSort, !this.readOnly); // force to false when readonly
+    this.saveBeforeFilter = toBoolean(this.saveBeforeFilter, !this.readOnly); // force to false when readonly
+    this.keepEditedRowOnSave = toBoolean(this.keepEditedRowOnSave, this.inlineEdition);
+    this.errorTranslateOptions = this.errorTranslateOptions || { separator: ', ', pathTranslator: this }; // Can be override in subclasses constructors
+
+    // Check ask user confirmation is possible
+    if (this.confirmBeforeDelete && !this.alertCtrl) throw Error("Missing 'alertCtrl' or 'injector' in component's constructor.");
+
+    // Defined unique id for settings for the page
+    this.settingsId = this.settingsId || this.generateTableId();
+
+    this.displayedColumns = this.getDisplayColumns();
+
+    // Load the sorted columns, from settings
+    {
+      const sortedColumn = this.getSortedColumn();
+      this.defaultSortBy = sortedColumn.id;
+      this.defaultSortDirection = sortedColumn.start;
+    }
+
+    this.defaultPageSize = this.getPageSize();
+
+    // Propagate error to event emitter
+    this.registerSubscription(this.errorSubject.subscribe((value) => this.onError.emit(value)));
+
+    // Propagate dirty to event emitter
+    this.registerSubscription(this.dirtySubject.subscribe((value) => this.onDirty.emit(value)));
+
+    // Propagate row dirty state to table
+    this.registerSubscription(
+      this.onStartEditingRow
+        .pipe(
+          filter((row) => row?.validator && true),
+          mergeMap((row) =>
+            row.validator.valueChanges.pipe(
+              filter(() => row.validator.dirty),
+              first(),
+              // DEBUG
+              //tap(() => console.debug("Propagate row's dirty to table..."))
+
+              // Stop if next another row, or destroying
+              takeUntil(this.onStartEditingRow),
+              takeUntil(this.destroySubject)
+            )
+          )
+        )
+        .subscribe(() => this.markAsDirty())
+    );
+
+    // Call datasource refresh, on each refresh events
+    this.registerSubscription(
+      this.onRefresh
+        .pipe(
+          startWith<any, any>((this.autoLoad ? {} : 'skip') as any),
+          switchMap((event: any) => {
+            this.dirtySubject.next(false);
+            this.selection.clear();
+            if (event === 'skip') {
+              return of(undefined);
+            }
+            if (!this._dataSource) {
+              if (this.debug) console.debug('[table] Skipping data load: no dataSource defined');
+              return of(undefined);
+            }
+            if (this.debug) console.debug('[table] Calling dataSource.watchAll()...');
+            return this._dataSource.watchAll(this.pageOffset, this.pageSize, this.sortActive, this.sortDirection, this._filter);
+          }),
+          catchError((err) => {
+            if (this.debug) console.error(err);
+            this.setError((err && err.message) || err);
+            return of(undefined); // Continue
+          })
+        )
+        .subscribe((res) => this.updateView(res as LoadResult<T> | undefined))
+    );
+
+    // Listen dataSource loading events
+    if (this._dataSource) this.listenDatasourceLoading(this._dataSource);
+
+    // Permanent selection behavior
+    if (this.permanentSelectionAllowed) this.initPermanentSelection();
+  }
+
+  ngAfterViewInit() {
+    // Detect when parent ngOnInit() not call
+    if (this.debug && !this.displayedColumns)
+      console.warn(`[table] Missing 'displayedColumns'. Did you call parent ngOnInit() in component ${this.constructor.name} ?`);
+
+    // Start listening sort and paginator events
+    // noinspection JSIgnoredPromiseFromCall
+    this.listenSortAndPaginationEvents();
+  }
+
+  ngOnDestroy() {
+    this._subscription.unsubscribe();
+
+    // Unsubscribe column value changes
+    Object.keys(this._cellValueChangesDefs).forEach((col) => this.stopCellValueChanges(col, true));
+    this._cellValueChangesDefs = {};
+
+    this.readySubject.unsubscribe();
+    this.loadingSubject.unsubscribe();
+    this.savingSubject.unsubscribe();
+    this.errorSubject.unsubscribe();
+    this.dirtySubject.unsubscribe();
+
+    this.onRefresh.unsubscribe();
+    this.onOpenRow.unsubscribe();
+    this.onNewRow.unsubscribe();
+    this.onStartEditingRow.unsubscribe();
+    this.onConfirmEditCreateRow.unsubscribe();
+    this.onCancelOrDeleteRow.unsubscribe();
+    this.onBeforeDeleteRows.unsubscribe();
+    this.onBeforeCancelRows.unsubscribe();
+    this.onBeforeSave.unsubscribe();
+    this.onAfterDeletedRows.unsubscribe();
+    this.onSort.unsubscribe();
+    this.onDirty.unsubscribe();
+    this.onError.unsubscribe();
+
+    this.destroySubject.next();
+    this.destroySubject.unsubscribe();
+  }
+
+  async updateView(
+    res: LoadResult<T> | undefined,
+    opts?: {
+      emitEvent?: boolean;
+    }
+  ): Promise<void> {
+    if (!res) return; // Skip (e.g error)
+    if (res && res.data) {
+      this.visibleRowCount = res.data.length;
+      this.totalRowCount = isNotNil(res.total)
+        ? res.total
+        : ((this.paginator && this.paginator.pageIndex * (this.paginator.pageSize || DEFAULT_PAGE_SIZE)) || 0) + this.visibleRowCount;
+      if (this.debug) console.debug(`[table] ${res.data.length} rows loaded`);
+    } else {
+      //if (this.debug) console.debug('[table] NO rows loaded');
+      this.totalRowCount = 0;
+      this.visibleRowCount = 0;
+    }
+
+    if (!opts || opts.emitEvent !== false) {
+      await this.markAsUntouched({ emitEvent: false });
+      this.markAsPristine({ emitEvent: false });
+      this.markAsLoaded({ emitEvent: false });
+    }
+
+    this.markForCheck();
+  }
+
+  setDatasource(datasource: EntitiesAsyncTableDataSource<T, F, ID>) {
+    if (this._dataSource) throw new Error('[table] dataSource already set !');
+    if (datasource && this._dataSource !== datasource) {
+      this._dataSource = datasource;
+      if (this._initialized) this.listenDatasourceLoading(datasource);
+    }
+  }
+
+  resetDataSource() {
+    if (this._dataSourceLoadingSubscription) {
+      this._dataSourceLoadingSubscription.unsubscribe();
+      this._subscription.remove(this._dataSourceLoadingSubscription);
+    }
+    this._dataSource = null;
+  }
+
+  addColumnDef(column: CdkColumnDef) {
+    this.table.addColumnDef(column);
+  }
+
+  removeColumnDef(column: CdkColumnDef) {
+    this.table.removeColumnDef(column);
+  }
+
+  async setFilter(filter: F, opts?: { emitEvent?: boolean; permanentSelectionChangedPrevented?: boolean }) {
+    opts = opts || { emitEvent: true };
+
+    // Prevent permanent selection change events
+    this.permanentSelectionChangedPrevented = toBoolean(opts.permanentSelectionChangedPrevented, this.permanentSelectionChangedPrevented);
+
+    if (this.saveBeforeFilter) {
+      // if a dirty table is to be saved before filter
+      if (this.dirty) {
+        // Save
+        if (await this.saveBeforeAction('filter')) {
+          // Apply filter only if user didn't cancel the save or the save is ok
+          this.applyFilter(filter, opts);
+        }
+      } else {
+        // apply filter on non-dirty table
+        this.applyFilter(filter, opts);
+      }
+    } else {
+      // apply filter directly
+      this.applyFilter(filter, opts);
+    }
+  }
+
+  async confirmAndAdd(event?: Event, row?: AsyncTableElement<T>): Promise<boolean> {
+    if (!(await this.confirmEditCreate(event, row))) {
+      return false;
+    }
+    // Add row
+    return this.addRow(event);
+  }
+
+  async confirmAndBackward(event?: Event, row?: AsyncTableElement<T>): Promise<boolean> {
+    // Deleting edited row, if empty and not dirty
+    if (this.dataSource.hasSomeEditingRow()) {
+      for (const editingRow of this.dataSource.getEditingRows().filter((row) => row.id === -1 && row.invalid && !row.dirty)) {
+        await this.deleteNewRow(event, editingRow);
+      }
+
+      // Wait deletion is done, then edit previous row (by id, because of reloading)
+      await this.waitIdle();
+      await this.editRowById(event, row.id, { focusColumn: this.lastUserColumn });
+      return true;
+    }
+
+    // Edit row, focusing at the end
+    await this.editRow(event, row, { focusColumn: this.lastUserColumn });
+    return true;
+  }
+
+  async confirmAndForward(event?: Event, row?: AsyncTableElement<T>): Promise<boolean> {
+    if (!this.inlineEdition) return false;
+
+    const confirmed = await this.confirmEditCreate(event, row);
+    if (!confirmed) return false; // Not confirmed
+
+    // Edit next row
+    await this.editRowById(event, row.id + 1, { focusColumn: this.firstUserColumn });
+    return true;
+  }
+
+  /**
+   * Confirm the creation of the given row, or if not specified the currently edited row
+   *
+   * @param event
+   * @param row
+   */
+  async confirmEditCreate(event?: Event, row?: AsyncTableElement<T>): Promise<boolean> {
+    row = row || this.dataSource.getSingleEditingRow();
+    if (!row || !row.editing) return true; // no row to confirm
+
+    // Stop event
+    event?.stopPropagation();
+
+    // Confirmation edition or creation
+    const confirmed = await row.confirmEditCreate();
+
+    if (confirmed) {
+      // Mark table as dirty (if row is dirty)
+      if (row.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) {
+      // 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) {
+        const error = this.getRowError(row);
+        this.setError(error);
+      }
+    }
+
+    // Not confirmed
+    return false;
+  }
+
+  async cancelOrDelete(event: Event, row: AsyncTableElement<T>, opts?: { interactive?: boolean; keepEditing?: boolean }) {
+    // Delete new row
+    if (row.id === -1) {
+      await this.deleteNewRow(event, row);
+    }
+    // Delete existing (but not editing) row
+    else if (!row.editing) {
+      await this.deleteExistingRow(event, row, opts);
+    }
+    // Cancel existing (and editing) row
+    else {
+      await this.cancelExistingRow(event, row, opts);
+    }
+  }
+
+  async addRow(event?: Event, insertAt?: number, opts?: { focusColumn?: string; editing?: boolean }): Promise<boolean> {
+    if (this.debug) console.debug('[table] Asking for new row...');
+    if (!this._enabled) return false;
+
+    // Use modal if inline edition is disabled
+    if (!this.inlineEdition) {
+      await this.openNewRowDetail(event);
+      return false;
+    }
+
+    // Try to finish edited row first
+    if (!(await this.confirmEditCreate())) {
+      return false;
+    }
+
+    // Add new row
+    const row = await this.addRowToTable(insertAt, opts);
+    return !!row;
+  }
+
+  async save(opts?: { keepEditing?: boolean }): Promise<boolean> {
+    opts = {
+      keepEditing: this.keepEditedRowOnSave,
+      ...opts,
+    };
+    if (this.readOnly) {
+      throw { code: ErrorCodes.TABLE_READ_ONLY, message: 'ERROR.TABLE_READ_ONLY' };
+    }
+
+    this.resetError();
+
+    // Keep edited row id (should be done BEFORE confirmEditCreate() )
+    const editedRow = this.dataSource.getSingleEditingRow();
+    this.previouslyEditedRowId = opts.keepEditing ? (editedRow?.editing ? editedRow.id : undefined) || this.singleSelectedRow?.id : undefined;
+    const previouslyEditedRowId = this.previouslyEditedRowId;
+    const previouslyEditedData = opts.keepEditing
+      ? (isNotNil(previouslyEditedRowId) && editedRow?.currentData) || this.singleSelectedRow?.currentData
+      : undefined;
+
+    if (!(await this.confirmEditCreate())) {
+      throw { code: ErrorCodes.TABLE_INVALID_ROW_ERROR, message: 'ERROR.TABLE_INVALID_ROW_ERROR' };
+    }
+
+    // Mark as saving
+    this.markAsSaving();
+
+    try {
+      // Calling service save()
+      if (this.debug) console.debug('[table] Calling dataSource.save()...');
+      const isOK = await this._dataSource.save();
+
+      if (isOK) this.markAsPristine();
+
+      return isOK;
+    } catch (err) {
+      this.setError((err && err.message) || err);
+      throw err;
+    } finally {
+      this.markAsSaved();
+
+      // Restore previous row
+      if (isNotNil(previouslyEditedRowId)) {
+        await this.selectRowByIdOrData(previouslyEditedRowId, previouslyEditedData);
+      }
+    }
+  }
+
+  async cancel(event?: Event, opts?: { interactive?: boolean }) {
+    // Check confirmation
+    if ((!opts || opts.interactive !== false) && this.dirty && (this.confirmBeforeCancel || this.onBeforeCancelRows.observed)) {
+      event?.stopPropagation();
+      if (!(await this.canCancelRows())) {
+        return;
+      }
+    }
+
+    this.emitRefresh();
+  }
+
+  async duplicateRow(
+    event?: Event,
+    row?: AsyncTableElement<T>,
+    opts?: {
+      includedProperties?: string[];
+      excludedProperties?: string[];
+    }
+  ) {
+    event?.stopPropagation();
+
+    row = row || this.singleSelectedRow;
+    if (!row || !(await this.confirmEditCreate(event, row))) {
+      return false;
+    }
+
+    const newRow = await this.addRowToTable(row.id + 1);
+    if (!newRow) throw new Error('Cannot add new row to table');
+
+    const source = row.cloneData();
+    let target: any;
+
+    // Copy included properties only
+    if (isNotEmptyArray(opts?.includedProperties)) {
+      target = {};
+      // Clone (deep copy)
+      opts.includedProperties.forEach((path) => {
+        setPropertyByPath(target, path, getPropertyByPath(source, path));
+      });
+    }
+
+    // Copy all properties
+    else {
+      target = source;
+
+      // Clean id and updateDate
+      EntityUtils.cleanIdAndUpdateDate(target, undefined);
+    }
+
+    // Restore excluded properties (e.g. rankOrder, etc)
+    if (isNotEmptyArray(opts?.excludedProperties)) {
+      const newData = newRow.currentData;
+      opts.excludedProperties.forEach((path) => {
+        setPropertyByPath(target, path, getPropertyByPath(newData, path));
+      });
+    }
+
+    if (newRow.validator) {
+      newRow.validator.patchValue(target);
+      newRow.validator.markAsDirty();
+    } else {
+      if (newRow.currentData?.fromObject) {
+        newRow.currentData.fromObject(target);
+      } else {
+        newRow.currentData = target;
+      }
+      this.markAsDirty();
+    }
+
+    // select
+    await this.clickRow(undefined, newRow);
+  }
+
+  /** Whether the number of selected elements matches the total number of rows. */
+  isAllSelected() {
+    // DEBUG
+    //console.debug('isAllSelected. lengths', this.selection.selected.length, this.totalRowCount);
+
+    return this.selection.selected.length === this.totalRowCount || this.selection.selected.length === this.visibleRowCount;
+  }
+
+  /** Selects all rows if they are not all selected; otherwise clear selection. */
+  async masterToggle() {
+    if (this.loading) return;
+    if (this.isAllSelected()) {
+      this.selection.clear();
+    } else {
+      const rows = this._dataSource.getRows();
+      this.selection.setSelection(...rows);
+    }
+  }
+
+  async deleteSelection(event: Event, opts?: { interactive?: boolean }): Promise<number> {
+    const deleteCount = await this.deleteRows(event, this.selection.selected, opts);
+    if (deleteCount > 0) this.selection.clear();
+    return deleteCount;
+  }
+
+  /**
+   *
+   * @param event
+   * @param row
+   * @param opts Use interactive=false to avoid user interaction (e.g. user confirmation)
+   *  And to force deletion even if table is busy
+   */
+  async deleteRow(event: Event | null, row: AsyncTableElement<T>, opts?: { interactive?: boolean }): Promise<boolean> {
+    const deleteCount = await this.deleteRows(event, [row], opts);
+    return deleteCount === 1;
+  }
+
+  /**
+   *
+   * @param event
+   * @param rows
+   * @param opts Use interactive=false to avoid user interaction (e.g. user confirmation)
+   *    And to force deletion even if table is busy
+   */
+  async deleteRows(event: Event | null, rows: AsyncTableElement<T>[], opts?: { interactive?: boolean }): Promise<number> {
+    if (this.readOnly) {
+      throw { code: ErrorCodes.TABLE_READ_ONLY, message: 'ERROR.TABLE_READ_ONLY' };
+    }
+    if (event?.defaultPrevented) return 0; // SKip
+    event?.preventDefault();
+    this.resetError();
+
+    if (!this._enabled || isEmptyArray(rows)) return 0; // Skip is disabled, or no rows to delete
+
+    if (this.loading && (!opts || opts.interactive !== false)) {
+      console.warn('[app-table] Skip deleteRows() because table is busy (loading). Use opts.interactive = false to force deletion');
+      return 0; // Skip if loading
+    }
+
+    // Make sure to keep newly created row
+    const editedRow = this.dataSource.getSingleEditingRow();
+    if (editedRow?.id === -1 && editedRow.editing && !rows.includes(editedRow)) {
+      const confirmed = await this.confirmEditCreate();
+      if (!confirmed) return 0; // Cannot delete (e.g. edited row is invalid)
+    }
+
+    // Check if can delete
+    const canDelete = await this.canDeleteRows(rows, opts);
+    if (!canDelete) 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
+    let tempRows = rows.slice().sort((a, b) => (a.id > b.id ? -1 : 1));
+
+    const deletedRows: AsyncTableElement<T>[] = [];
+
+    // If data need to be saved first
+    if (this.saveBeforeDelete) {
+      // Exclude invalid rows (because of save() will fail, when exists some invalid rows)
+      tempRows = tempRows.filter((row) => {
+        // Delete the row :
+        // - if newly created row (id = -1),
+        // - or if invalid and not editing (= not cancellable)
+        if (row.id === -1 || (!row.editing && row.invalid) /*do not use !valid because if row is disabled, it will be always !valid */) {
+          if (this.debug) console.debug(`[table] Delete row #${row.id}`);
+          this.selection.deselect(row);
+          row.delete();
+          this.visibleRowCount--;
+          this.totalRowCount--;
+          deletedRows.push(row);
+          return false; // Exclude from the list to delete using the service
+        }
+        // Cancel the row (and mark as pristine), when not valid but in edition
+        else if (row.editing && !row.valid) {
+          this.selection.deselect(row);
+          row.cancel();
+          // Mark row as pristine (if possible)
+          this.checkIfRowPristine(row, { emitEvent: false, onlySelf: true /*avoid propagation to table*/ });
+          return true; // Keep the row. the row will be deleted after the save
+        }
+
+        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 (deletedRows.length || tempRows.length) {
+        // Save data (e.g. when using memory service)
+        const saved = await this.saveBeforeAction('delete');
+        if (!saved) {
+          // Stop if save cancelled or save failed
+          return;
+        }
+      }
+    }
+
+    try {
+      // Apply deletion on datasource
+      // If no more rows to delete, continue anyway to clear editedRow and selection (issue IMAGINE-669)
+      if (tempRows.length) {
+        if (this.debug) console.debug(`[table] Delete ${tempRows.length} rows...`);
+        await this._dataSource.deleteAll(tempRows);
+      }
+
+      // DO not update manually, because watchALl().subscribe() will update this count
+      //this.totalRowCount -= deleteCount;
+      //this.visibleRowCount -= deleteCount;
+
+      // Deselect deleted rows
+      this.selection.deselect(...rows);
+
+      this.markAsDirty({ emitEvent: false /*markForCheck() is called just after*/ });
+      this.markForCheck();
+
+      this.onAfterDeletedRows.next(rows);
+
+      return rows.length;
+    } catch (err) {
+      this.setError((err && err.message) || err);
+      throw err;
+    }
+  }
+
+  async selectRowById(id: number): Promise<boolean> {
+    if (id === undefined) return false;
+    await this.waitIdle();
+    const row = this.dataSource.getRow(id);
+    if (!row) return false;
+    return this.clickRow(null, row);
+  }
+
+  /**
+   * Try to select row by data. Will use equals() to find same row's data
+   *
+   * @param data
+   */
+  async selectRowByData(data: T): Promise<boolean> {
+    if (data === undefined) return Promise.resolve(false);
+    await this.waitIdle();
+    const row = this.dataSource.getRows().find((row) => this.equals(row.currentData, data));
+    if (!row) return false;
+    return this.clickRow(null, row);
+  }
+
+  toggleSelectRow(event: Event | undefined, row: AsyncTableElement<T>) {
+    // /!\ DO NOT prevent default, otherwise the checkbox will not be updated
+    //event?.preventDefault();
+    event?.stopPropagation();
+    this.selection.toggle(row);
+  }
+
+  async clickRow(event: Event | undefined, row: AsyncTableElement<T>): Promise<boolean> {
+    if (this.loading) {
+      // Wait while loading, and loop
+      if (this.debug) console.debug('[table] Waiting before apply clickRow() (datasource is busy)...');
+      await this.waitIdle({ timeout: 2000 });
+    }
+
+    // DEBUG
+    //console.debug("[table] Detect click on row");
+
+    // Cancelled by event
+    if (event?.defaultPrevented) {
+      if (this.debug) console.debug('[table] clickRow event is defaultPrevented');
+      return false;
+    }
+
+    // Call onClickRow if observed
+    if (this.onClickRow.observed) {
+      this.onClickRow.next(row);
+      return true;
+    }
+
+    // Open the detail page (if not inline editing)
+    if (!this.inlineEdition) {
+      if (this._openingRow) return; // Prevent double click
+
+      if (event) {
+        event.stopPropagation();
+        event.preventDefault();
+      }
+
+      this._openingRow = true; // Prevent double click
+      this.markAsLoading();
+
+      this.openRow(row.currentData.id, row)
+        .catch((err) => console.error('Failed to open row', err)) // Continue
+        .then(() => {
+          this.markAsLoaded();
+
+          // Prevent double click (use an open throttle time)
+          if (this.openRowThrottleTime > 0) {
+            setTimeout(() => {
+              this._openingRow = false;
+            }, this.openRowThrottleTime);
+          } else {
+            this._openingRow = false;
+          }
+        });
+
+      return true;
+    }
+
+    // Start editing row
+    return this.editRow(event, row, { focusColumn: undefined /*force to use the click target*/ });
+  }
+
+  async moveRow(id: number, direction: number) {
+    await this.dataSource.move(id, direction);
+  }
+
+  ready(opts?: WaitForOptions): Promise<void> {
+    return waitForTrue(this.readySubject, { stop: this.destroySubject, ...opts });
+  }
+
+  waitIdle(opts?: WaitForOptions): Promise<void> {
+    if (!this.loadingSubject.value) return Promise.resolve();
+    return waitForFalse(this.loadingSubject, { stop: this.destroySubject, ...opts });
+  }
+
+  async openSelectColumnsModal(event?: Event): Promise<any> {
+    event?.preventDefault();
+
+    // Copy current columns (deep copy)
+    const columns = this.getCurrentColumns();
+
+    const hasTopModal = !!(await this.modalCtrl.getTop());
+    const modal = await this.modalCtrl.create({
+      component: TableSelectColumnsComponent,
+      componentProps: { columns },
+      cssClass: hasTopModal && 'stack-modal',
+    });
+
+    // Open the modal
+    await modal.present();
+
+    // On dismiss
+    const { data } = await modal.onDidDismiss();
+    if (!data) return; // CANCELLED
+
+    // Apply columns
+    const userColumns = (data || []).filter((c) => c.canHide === false || c.visible).map((c) => c.name) || [];
+    this.displayedColumns = RESERVED_START_COLUMNS.concat(userColumns).concat(RESERVED_END_COLUMNS);
+    this.markForCheck();
+
+    // Update user settings
+    await this.savePageSettings(userColumns, SETTINGS_DISPLAY_COLUMNS);
+  }
+
+  trackByFn(index: number, row: AsyncTableElement<T>): any {
+    return row.id;
+  }
+
+  doRefresh(event?: CompletableEvent) {
+    this.emitRefresh(event);
+
+    // When target wait for a complete (e.g. IonRefresher)
+    if (event?.target && event.target.complete) {
+      setTimeout(async () => {
+        await this.waitIdle();
+        event.target.complete();
+      });
+    }
+  }
+
+  getCurrentColumns(): ColumnItem[] {
+    const hiddenColumns = this.columns.slice(RESERVED_START_COLUMNS.length).filter((name) => this.displayedColumns.indexOf(name) === -1);
+    return this.displayedColumns
+      .concat(hiddenColumns)
+      .filter((name) => !RESERVED_START_COLUMNS.includes(name) && !RESERVED_END_COLUMNS.includes(name) && !this.excludesColumns.includes(name))
+      .map((name) => ({
+        name,
+        label: this.getI18nColumnName(name),
+        visible: this.displayedColumns.indexOf(name) !== -1,
+        canHide: this.getRequiredColumns().indexOf(name) === -1,
+      }));
+  }
+
+  async escapeEditingRow(event?: Event, row?: AsyncTableElement<T>) {
+    row = row || this.dataSource.getSingleEditingRow();
+    if (!row || !row.editing) return;
+
+    // DEBUG
+    //console.debug('[app-table] Cancel the row (keydown.escape)');
+
+    if (event) {
+      // Avoid to cancel the editor
+      event.preventDefault();
+      event.stopPropagation();
+    }
+
+    // If new row (no id)
+    if (row.id === -1) {
+      if (row.validator) {
+        // If pending: Wait end of validation, then loop
+        if (row.pending) {
+          await AppFormUtils.waitWhilePending(row.validator);
+        }
+
+        // Row is invalid: delete the row
+        if (row.invalid) {
+          await this.deleteNewRow(event, row);
+          return;
+        }
+      }
+    }
+    // If the row exists (has an id)
+    else {
+      // Call cancel function ,
+      // - if confirmation will be called before
+      // - or if row is pristine (not dirty)
+      if (this.confirmBeforeCancel || !row.dirty) {
+        await this.cancelExistingRow(event, row, { keepEditing: false });
+        return;
+      }
+    }
+
+    // By default, try to confirm the row
+    await this.confirmEditCreate(event, row);
+  }
+
+  translateFormPath(path: string): string {
+    // Can be overridden by subclasses, to resolve all field name
+
+    // Use columns key, has default name
+    const i18nColumnKey = this.getI18nColumnName(path);
+    return this.translate?.instant(i18nColumnKey) || i18nColumnKey;
+  }
+
+  /* -- protected method -- */
+
+  protected async editRow(event: Event | undefined, row: AsyncTableElement<T>, opts?: { focusColumn?: string }): Promise<boolean> {
+    if (!this._enabled || !this.inlineEdition) return false;
+    if (this.dataSource.getEditingRows().includes(row)) return true; // Already the edited row
+    if (event?.defaultPrevented) return false;
+
+    if (!(await this.confirmEditCreate())) {
+      return false;
+    }
+
+    if (!row.editing && !this.loading) {
+      this.focusColumn = (opts && opts.focusColumn) || this.focusColumn;
+      await this._dataSource.startEdit(row);
+    }
+    this.onStartEditingRow.emit(row);
+    return true;
+  }
+
+  /**
+   * Try to select row, by row.id, or by data. WIll use EntityUtils.equals()
+   *
+   * @param id
+   * @param data
+   * @protected
+   */
+  protected async selectRowByIdOrData(id: number, data?: T): Promise<boolean> {
+    let done = false;
+    try {
+      // Select by row id (if NOT a new row)
+      if (isNotNil(id) || id !== -1) {
+        done = await this.selectRowById(id);
+        if (done) return true;
+        console.warn('[app-table] Save: Cannot reselect row by row.id: ', id);
+      }
+
+      // Try by data
+      if (data) {
+        done = await this.selectRowByData(data);
+        if (done) return true;
+        console.warn('[app-table] Save: Cannot reselect row by data: ', data);
+      }
+
+      return false;
+    } catch (err) {
+      // Log, but continue
+      console.error((err && err.message) || err);
+      return false;
+    }
+  }
+
+  /**
+   * return the selected row if unique in selection
+   */
+  protected get singleSelectedRow(): AsyncTableElement<T> {
+    return this.selection.selected?.length === 1 ? this.selection.selected[0] : undefined;
+  }
+
+  protected async canDeleteRows(rows: AsyncTableElement<T>[], opts?: { interactive?: boolean }): Promise<boolean> {
+    // Check using emitter
+    if (this.onBeforeDeleteRows.observed) {
+      try {
+        const canDelete = await emitPromiseEvent(this.onBeforeDeleteRows, 'canDelete', {
+          detail: { rows },
+        });
+        if (!canDelete) return false;
+      } catch (err) {
+        if (err === 'CANCELLED') return false; // User cancel
+        console.error('Error while checking if can delete rows', err);
+        throw err;
+      }
+    }
+
+    // Ask user confirmation
+    if (this.confirmBeforeDelete && (!opts || opts.interactive !== false)) {
+      return this.askDeleteConfirmation(null, rows);
+    }
+    return true;
+  }
+
+  protected async canCancelRows(rows?: AsyncTableElement<T>[], opts?: { interactive?: boolean }): Promise<boolean> {
+    // Get dirty rows
+    rows = rows || this.dataSource.getRows().filter((row) => row.validator?.dirty);
+
+    if (isEmptyArray(rows)) return true; // No dirty: OK
+
+    // Check using emitter
+    if (this.onBeforeCancelRows.observed) {
+      try {
+        const isCancel = await emitPromiseEvent(this.onBeforeCancelRows, 'canCancel', {
+          detail: { rows },
+        });
+        if (!isCancel) return false;
+      } catch (err) {
+        if (err === 'CANCELLED') return false; // User cancel
+        console.error('Error while checking if can cancel rows', err);
+        throw err;
+      }
+    }
+
+    // Ask user confirmation
+    if (this.confirmBeforeCancel && (!opts || opts.interactive !== false)) {
+      return this.askCancelConfirmation(null, rows);
+    }
+    return true;
+  }
+
+  protected async saveBeforeAction(saveAction: SaveActionType): Promise<boolean> {
+    if (!this.dirty) {
+      // Continue without save
+      return true;
+    }
+
+    let save: boolean;
+    switch (saveAction) {
+      case 'delete':
+        save = this.saveBeforeDelete;
+        break;
+      case 'filter':
+        save = this.saveBeforeFilter;
+        break;
+      case 'sort':
+        save = this.saveBeforeSort;
+        break;
+      default:
+        save = true;
+    }
+
+    // Default behavior
+    let confirmed = true;
+
+    if (save) {
+      if (this.onBeforeSave.observed) {
+        // Ask confirmation
+        try {
+          const res = await emitPromiseEvent(this.onBeforeSave, 'beforeSave', {
+            detail: { action: saveAction, valid: this.valid },
+          });
+          confirmed = res.confirmed;
+          save = res.save;
+        } catch (err) {
+          if (err === 'CANCELLED') return false; // User cancel
+          console.error('Error while checking if can delete rows', err);
+          throw err;
+        }
+      }
+    }
+
+    if (confirmed) {
+      if (save) {
+        // User confirmed save
+        const saved = await this.save();
+        this.markAsDirty(); // Restore dirty flag
+        return saved;
+      }
+      return true; // No save but continue action
+    }
+
+    return false; // User cancel the action
+  }
+
+  /**
+   * Open a row detail view. By default, will to open row detail page.
+   * Can be overridden by subclasses, BUT prefer to subscribe on onOpenRow
+   *
+   * @param id
+   * @param row
+   * @protected
+   */
+  protected async openRow(id: ID, row: AsyncTableElement<T>): Promise<boolean> {
+    if (this.allowRowDetail) {
+      if (this.debug && this.dirty) {
+        console.warn('[table] Opening row details, but table has unsaved changes!');
+      }
+
+      if (this.onOpenRow.observed) {
+        // Clear selection (because next route can change the current table content)
+        this.selection.clear();
+        this.onOpenRow.emit(row);
+        return true;
+      }
+
+      // No ID defined: unable to open details
+      if (isNil(id)) {
+        console.warn('[table] Opening row details, but data has no id!');
+        return false;
+      }
+
+      // Clear selection (because next route can change the current table content)
+      this.selection.clear();
+
+      return this.navController.navigateForward(`${this.router.url}/${id}`, {
+        queryParams: {},
+      });
+    }
+    return false;
+  }
+
+  protected async openNewRowDetail(event?: any): Promise<boolean> {
+    if (!this.allowRowDetail) return false;
+
+    if (this.onNewRow.observed) {
+      this.onNewRow.emit(event);
+      return true;
+    }
+
+    // Clear selection (because next route can change the current table content)
+    this.selection.clear();
+
+    return this.navController.navigateForward(`${this.router.url}/new`);
+  }
+
+  // can be overridden to add more required columns
+  protected getRequiredColumns() {
+    return DEFAULT_REQUIRED_COLUMNS;
+  }
+
+  protected getUserColumns(): string[] {
+    return this.getPageSettings(SETTINGS_DISPLAY_COLUMNS);
+  }
+
+  protected getSortedColumn(): MatSortable {
+    const data = this.getPageSettings(SETTINGS_SORTED_COLUMN);
+    const parts = data && data.split(':');
+    if (parts && parts.length === 2 && this.columns.includes(parts[0])) {
+      return { id: parts[0], start: parts[1] === 'desc' ? 'desc' : 'asc', disableClear: false };
+    }
+    if (this.defaultSortBy) {
+      return { id: this.defaultSortBy, start: this.defaultSortDirection || 'asc', disableClear: false };
+    }
+    return { id: 'id', start: 'asc', disableClear: false };
+  }
+
+  protected getPageSize(): number {
+    const pageSize = this.getPageSettings<number>(SETTINGS_PAGE_SIZE);
+    return pageSize || this.defaultPageSize;
+  }
+
+  protected getDisplayColumns(): string[] {
+    let userColumns = this.getUserColumns();
+
+    // No user override
+    if (!userColumns) {
+      // Return default, without columns to hide
+      return this.columns.filter((column) => !this.excludesColumns.includes(column));
+    }
+
+    // Get fixed start columns
+    const fixedStartColumns = this.columns.filter((c) => RESERVED_START_COLUMNS.includes(c));
+
+    // Remove end columns
+    const fixedEndColumns = this.columns.filter((c) => RESERVED_END_COLUMNS.includes(c));
+
+    // Remove fixed columns from user columns
+    userColumns = userColumns.filter((c) => !fixedStartColumns.includes(c) && !fixedEndColumns.includes(c) && this.columns.includes(c));
+
+    // Add required columns if missing
+    userColumns.push(
+      ...this.getRequiredColumns().filter((c) => !fixedStartColumns.includes(c) && !fixedEndColumns.includes(c) && !userColumns.includes(c))
+    );
+
+    return (
+      fixedStartColumns
+        .concat(userColumns)
+        .concat(fixedEndColumns)
+        // Remove columns to hide
+        .filter((column) => !this.excludesColumns.includes(column))
+    );
+  }
+
+  /**
+   * Recompute display columns
+   *
+   * @protected
+   */
+  protected updateColumns() {
+    this.displayedColumns = this.getDisplayColumns();
+    if (!this.loading) this.markForCheck();
+  }
+
+  protected registerSubscription(sub: Subscription) {
+    this._subscription.add(sub);
+  }
+
+  protected unregisterSubscription(sub: Subscription) {
+    this._subscription.remove(sub);
+  }
+
+  protected registerAutocompleteField<E = any, EF = any>(
+    fieldName: string,
+    options?: MatAutocompleteFieldAddOptions<E, EF>
+  ): MatAutocompleteFieldConfig<E, EF> {
+    return this._autocompleteConfigHolder.add(fieldName, options);
+  }
+
+  protected getI18nColumnName(columnName: string) {
+    return (this.i18nColumnPrefix || '') + changeCaseToUnderscore(columnName).toUpperCase();
+  }
+
+  protected generateTableId() {
+    // noinspection JSNonASCIINames
+    const meta = this.constructor['ɵcmp'];
+    // Get a component unique name - See https://stackoverflow.com/questions/60114682/how-to-access-components-unique-encapsulation-id-in-angular-9
+    const componentId = (meta && (meta.selectors?.[0] || meta.id)) || this.constructor.name;
+    const id =
+      this.location
+        .path(true)
+        .replace(/[?].*$/g, '')
+        .replace(/\/\d+/g, '_id') +
+      '_' +
+      componentId;
+    //if (this.debug) console.debug('[table] id = ' + id);
+    return id;
+  }
+
+  protected async addRowToTable(
+    insertAt?: number,
+    opts?: { focusColumn?: string; editing?: boolean; emitEvent?: boolean }
+  ): Promise<AsyncTableElement<T> | undefined> {
+    // Try to finish edited row first
+    if (!(await this.confirmEditCreate())) {
+      console.warn('[table] Cannot add new row, because the previous edited row cannot be confirmed');
+      return undefined;
+    }
+
+    const editing = this.inlineEdition && (!opts || opts.editing !== false); // true by default, if inlineEdition
+
+    const row = await this._dataSource.createNew(insertAt, { editing });
+    if (!row) return undefined;
+
+    if (row.editing) {
+      // Update focused column
+      this.focusFirstColumn = true;
+      this.focusColumn = opts?.focusColumn || this.firstUserColumn;
+
+      // Emit start editing event
+      this.onStartEditingRow.emit(row);
+    }
+
+    this.totalRowCount++;
+    this.visibleRowCount++;
+
+    this.markAsDirty({ emitEvent: false /*markForCheck() is called just after*/ });
+
+    // Emit event
+    if (!opts || opts.emitEvent !== false) this.markForCheck();
+
+    return row;
+  }
+
+  protected registerCellValueChanges(name: string, formPath?: string, emitInitialValue?: boolean): Observable<any> {
+    formPath = formPath || name;
+    emitInitialValue = emitInitialValue || false;
+    let def = this._cellValueChangesDefs[name];
+    if (def && (def.formPath !== formPath || def.emitInitialValue !== emitInitialValue)) {
+      throw Error("Already register a cell value change for this name, with different 'formPath' or 'emitInitialValue'. Please use same arguments.");
+    }
+
+    // Not exists: register new definition
+    if (!def) {
+      if (this.debug) console.debug(`[table] New listener {${name}} for value changes on path ${formPath}`);
+      def = {
+        subject: new Subject<any>(),
+        subscription: null,
+        formPath,
+        emitInitialValue,
+      };
+      this._cellValueChangesDefs[name] = def;
+
+      // Start the listener, when editing starts
+      this.registerSubscription(this.onStartEditingRow.subscribe((row) => this.startCellValueChanges(name, row)));
+    }
+
+    return def.subject;
+  }
+
+  protected setShowColumn(columnName: string, show: boolean, opts?: { emitEvent?: boolean }) {
+    if (!this.excludesColumns.includes(columnName) !== show) {
+      if (!show) {
+        this.excludesColumns.push(columnName);
+      } else {
+        const index = this.excludesColumns.findIndex((value) => value === columnName);
+        if (index >= 0) this.excludesColumns.splice(index, 1);
+      }
+
+      // Recompute display columns
+      if (this.displayedColumns && (!opts || opts.emitEvent !== false)) {
+        this.updateColumns();
+      }
+    }
+  }
+
+  protected getShowColumn(columnName: string): boolean {
+    return !this.excludesColumns.includes(columnName);
+  }
+
+  protected startsWithUpperCase(input: string, search: string): boolean {
+    return input && input.toUpperCase().startsWith(search);
+  }
+
+  protected markForCheck() {
+    this.cd.markForCheck();
+  }
+
+  protected detectChanges() {
+    this.cd.detectChanges();
+  }
+
+  protected async askDeleteConfirmation(event?: Event, rows?: AsyncTableElement<T>[]): Promise<boolean> {
+    if (this.undoableDeletion) {
+      // Special message, for undoable deletion
+      return Alerts.askConfirmation(rows?.length === 1 ? 'CONFIRM.DELETE_ROW' : 'CONFIRM.DELETE_ROWS', this.alertCtrl, this.translate, event);
+    }
+    // Immediate deletion action
+    return Alerts.askActionConfirmation(this.alertCtrl, this.translate, true, event);
+  }
+
+  protected async askCancelConfirmation(event?: Event, rows?: AsyncTableElement<T>[]): Promise<boolean> {
+    return Alerts.askConfirmation(rows?.length === 1 ? 'CONFIRM.CANCEL_ROW' : 'CONFIRM.CANCEL_ROWS', this.alertCtrl, this.translate, event);
+  }
+
+  protected async askRestoreConfirmation(event?: Event): Promise<boolean> {
+    return Alerts.askActionConfirmation(this.alertCtrl, this.translate, false, event);
+  }
+
+  protected async showToast(opts: ShowToastOptions) {
+    if (!this.toastController) throw new Error("Missing toastController in component's constructor");
+    return Toasts.show(this.toastController, this.translate, opts);
+  }
+
+  protected resetError(opts?: { emitEvent?: boolean }) {
+    this.setError(undefined, opts);
+  }
+
+  protected getRowError(row?: AsyncTableElement<T>, opts?: FormErrorTranslateOptions): string {
+    row = row || this.dataSource.getSingleEditingRow();
+    if (!row || !this.formErrorAdapter) return undefined;
+
+    return this.formErrorAdapter.translateFormErrors(row.validator, {
+      ...this.errorTranslateOptions,
+      ...opts,
+    });
+  }
+
+  protected setError(value: string, opts?: { emitEvent?: boolean }) {
+    if (this.errorSubject.value !== value) {
+      this.errorSubject.next(value);
+      if (!opts || opts.emitEvent !== false) {
+        this.markForCheck();
+      }
+    }
+  }
+
+  /**
+   * Compare data equality (default by id, using EntityUtils.equals())
+   * Can be overridden to add additional properties to compare
+   *
+   * @param d1
+   * @param d2
+   * @protected
+   */
+  protected equals(d1: T, d2: T): boolean {
+    return EntityUtils.equals(d1, d2, 'id');
+  }
+
+  protected markRowAsDirty(row?: AsyncTableElement<T>, opts?: { onlySelf?: boolean; emitEVent?: boolean }) {
+    row = row || this.dataSource.getSingleEditingRow();
+    if (row) row.validator?.markAsDirty(opts);
+    this.markAsDirty(opts);
+  }
+
+  protected getPageSettings<T = any>(propertyName?: string): T {
+    return this.settings.getPageSettings(this.settingsId, propertyName);
+  }
+
+  protected async savePageSettings(value: any, propertyName?: string) {
+    await this.settings.savePageSetting(this.settingsId, value, propertyName);
+  }
+
+  protected emitRefresh(value?: any) {
+    // Emit onRefresh if not closed (can happen if component is destroyed to early)
+    if (!!this.onRefresh && !this.onRefresh.closed) {
+      this.onRefresh.emit(value);
+    }
+  }
+
+  /**
+   * Initialize the permanent selection model
+   *
+   * @protected
+   */
+  protected initPermanentSelection() {
+    if (this.permanentSelection) throw new Error('initPermanentSelection() already called!');
+
+    this.permanentSelection = new SelectionModel<T>(true, []);
+
+    // Listen sort change
+    this.registerSubscription(
+      this.onSort.subscribe(() => (this.permanentSelectionChangedPrevented = true)) // prevent selection change on sort
+    );
+
+    // Listen datasource update
+    this.registerSubscription(
+      this.dataSource.rowsSubject
+        // restore the 'adding' selection (for example after a page or sort change)
+        .subscribe((rows) => {
+          this.permanentSelectionChangedPrevented = true;
+          try {
+            const permanentSelectionIds = (this.permanentSelection.selected || []).map(EntityUtils.getId);
+            this.selection.setSelection(...rows.filter((row) => permanentSelectionIds.includes(AppTableUtils.getEntityId(row))));
+            this.markForCheck();
+          } finally {
+            this.permanentSelectionChangedPrevented = false;
+          }
+        })
+    );
+
+    // Listen selection change
+    this.registerSubscription(
+      this.selection.changed.pipe(filter(() => !this.permanentSelectionChangedPrevented)).subscribe((selectionChange) => {
+        // add to selection
+        if (selectionChange.added.length) {
+          this.permanentSelection.setSelection(
+            ...(this.permanentSelection.selected || [])
+              // Add new elements
+              .concat(...AppTableUtils.getEntities(selectionChange.added).filter(EntityUtils.hasId))
+              // Avoid duplicated entities (Mantis #55351)
+              .filter(EntityUtils.arrayDistinctFilterFn)
+          );
+        }
+        // remove from selection
+        if (selectionChange.removed.length) {
+          const removedIds = AppTableUtils.getEntityIds(selectionChange.removed);
+          this.permanentSelection.setSelection(
+            ...(this.permanentSelection.selected || []).filter((entity) => EntityUtils.hasId(entity) && !removedIds.includes(entity.id))
+          );
+        }
+        this.markForCheck();
+      })
+    );
+  }
+
+  /* -- private method -- */
+
+  private async listenSortAndPaginationEvents() {
+    if (!this.table) {
+      // DEBUG only -- alert user that table not found in template
+      if (this.debug) {
+        setTimeout(
+          () =>
+            !this.table &&
+            console.warn(`[table] Missing <mat-table> in the HTML template (after waiting 500ms)! Component: ${this.constructor.name}`),
+          500
+        );
+      }
+
+      // Make sure to wait the table
+      await waitFor(() => !!this.table, { stop: this.destroySubject, stopError: false /*avoid error when destorying the table*/ });
+    }
+
+    this.registerSubscription(
+      merge(
+        // Listen sort events
+        (this.sort &&
+          this.sort.sortChange.pipe(
+            filter(() => !this.sort.disabled),
+            mergeMap(async () => this.saveBeforeAction('sort')),
+            filter((res) => res === true),
+            // Save sort in settings
+            tap(() => {
+              const value = [this.sort.active, this.sort.direction || 'asc'].join(':');
+              this.savePageSettings(value, SETTINGS_SORTED_COLUMN);
+            })
+          )) ||
+          EMPTY,
+
+        // Listen paginator events
+        (this.paginator &&
+          this.paginator.page.pipe(
+            mergeMap((_) => this.saveBeforeAction('sort')),
+            filter((saved) => saved === true),
+            // Save page size in settings
+            tap(() => this.savePageSettings(this.paginator.pageSize, SETTINGS_PAGE_SIZE))
+          )) ||
+          EMPTY
+      )
+        // Refresh on any sort or paginator events
+        .subscribe((value) => {
+          this.onSort.emit(value);
+          this.emitRefresh(value);
+        })
+    );
+
+    // If the user changes the sort order, reset back to the first page.
+    if (this.sort && this.paginator) {
+      this.registerSubscription(this.sort.sortChange.pipe(filter(() => !this.sort.disabled)).subscribe(() => (this.paginator.pageIndex = 0)));
+    }
+  }
+
+  private async editRowById(event: Event | undefined, id: number, opts?: { focusColumn?: string }) {
+    if (id < 0) return;
+    if (id >= this.visibleRowCount) {
+      await this.addRow(event, undefined, { ...opts, editing: true });
+    } else {
+      const row = this.dataSource.getRow(id);
+      await this.editRow(event, row, opts);
+    }
+  }
+
+  private setLoading(value: boolean, opts?: { emitEvent?: boolean }) {
+    if (!this.loadingSubject.closed && this.loadingSubject.value !== value) {
+      this.loadingSubject.next(value);
+
+      if (!opts || opts.emitEvent !== false) {
+        this.markForCheck();
+      }
+    }
+  }
+
+  private async deleteNewRow(event: Event | undefined, row: AsyncTableElement<T>) {
+    // Make sure row will be cancelled, and NOT deleted
+    if (row.id !== -1) throw new Error('Row must have id = -1');
+    event?.stopPropagation();
+
+    this.selection.clear();
+    await this._dataSource.cancelOrDelete(row);
+    this.resetError();
+
+    this.onCancelOrDeleteRow.next(row);
+    this.totalRowCount--;
+    this.visibleRowCount--;
+  }
+
+  private async deleteExistingRow(event: Event | null, row: AsyncTableElement<T>, opts?: { interactive?: boolean }) {
+    // Make sure row will be cancelled, and NOT deleted
+    if (row.id === -1) throw new Error('Row must have an id');
+
+    if (event?.defaultPrevented) return 0; // SKip
+    event?.preventDefault();
+
+    await this.deleteRow(null, row, opts);
+  }
+
+  private async cancelExistingRow(event: Event | undefined, row: AsyncTableElement<T>, opts?: { interactive?: boolean; keepEditing?: boolean }) {
+    // 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 && row.dirty && (this.confirmBeforeCancel || this.onBeforeCancelRows.observed)) {
+      event?.stopPropagation();
+      if (!(await this.canCancelRows([row], opts))) {
+        return;
+      }
+    }
+
+    const keepEditing = row.editing && (!opts || opts.keepEditing !== false);
+    await this._dataSource.cancelOrDelete(row);
+    this.onCancelOrDeleteRow.next(row);
+
+    // Mark row as pristine
+    await this.checkIfRowPristine(row);
+
+    // Restore editing state
+    if (keepEditing) {
+      await this.editRow(undefined, row);
+    }
+  }
+
+  private async checkIfRowPristine(row: AsyncTableElement<T>, opts?: { emitEvent?: boolean; onlySelf?: boolean }) {
+    // Mark row as pristine
+    const markRowAsPristine = this.dataSource?.config.restoreOriginalDataOnCancel === true;
+    if (markRowAsPristine) {
+      row.validator?.markAsPristine();
+
+      // Check if table is now pristine
+      if (!opts || opts.onlySelf !== true) {
+        await this.checkIfPristine(opts);
+      }
+    }
+  }
+
+  private async checkIfPristine(opts?: { emitEvent?: boolean }) {
+    if (!this.dirty) return; // Already pristine
+
+    const rows = this._dataSource.getRows();
+    const pristine = (rows || []).findIndex((row) => row.dirty) === -1;
+    if (pristine) this.markAsPristine(opts);
+  }
+
+  private applyFilter(filter: F, opts: { emitEvent?: boolean }) {
+    if (this.debug) console.debug('[table] Applying filter', filter);
+    this._filter = filter;
+    if (opts && opts.emitEvent) {
+      if (this.paginator && this.paginator.pageIndex > 0) {
+        this.paginator.pageIndex = 0;
+      }
+      this.emitRefresh();
+    }
+  }
+
+  private listenDatasourceLoading(dataSource: EntitiesAsyncTableDataSource<T, F, ID>) {
+    if (!dataSource) throw new Error('[table] dataSource not set !');
+
+    // Cleaning previous subscription on datasource
+    if (isNotNil(this._dataSourceLoadingSubscription)) {
+      if (this.debug) console.debug('[table] Many call to listenDatasource(): Cleaning previous subscriptions...');
+      this._dataSourceLoadingSubscription.unsubscribe();
+      this.unregisterSubscription(this._dataSourceLoadingSubscription);
+    }
+
+    // Propage loading to table
+    this._dataSourceLoadingSubscription = this._dataSource.loadingSubject
+      .pipe(
+        filter(isNotNil), // filter out 'undefined'
+        distinctUntilChanged(),
+
+        // If changed to True: propagate as soon as possible
+        tap((loading) => loading && this.setLoading(true)),
+
+        // If changed to False: wait 250ms before propagate (to make sure the spinner has been displayed)
+        debounceTime(250),
+        tap((loading) => !loading && this.setLoading(false))
+      )
+      .subscribe();
+    this.registerSubscription(this._dataSourceLoadingSubscription);
+  }
+
+  private startCellValueChanges(name: string, row: AsyncTableElement<T>) {
+    const def = this._cellValueChangesDefs[name];
+    if (!def) {
+      console.warn('[table] Listener with name {' + name + '} not registered! Please call registerCellValueChanges() before;');
+      return;
+    }
+    // Stop previous subscription
+    if (def.subscription) {
+      def.subscription.unsubscribe();
+      def.subscription = null;
+    } else {
+      if (this.debug) console.debug(`[table] Start values changes on row path {${def.formPath}}`);
+    }
+
+    // Listen value changes, and redirect to event emitter
+    const control = row.validator && AppFormUtils.getControlFromPath(row.validator, def.formPath);
+    if (!control) {
+      console.warn(`[table] Could not listen cell changes: no validator or invalid form path {${def.formPath}}`);
+    } else {
+      def.subscription = control.valueChanges
+        .pipe(
+          // don't emit if control is disabled
+          filter(() => control.enabled)
+        )
+        .subscribe((value) => def.subject.next(value));
+
+      // Emit the actual value
+      if (def.emitInitialValue !== false) {
+        def.subject.next(control.value);
+      }
+    }
+  }
+
+  private stopCellValueChanges(name: string, destroy?: boolean) {
+    const def = this._cellValueChangesDefs[name];
+    if (!def) return;
+    if (def.subscription) {
+      if (this.debug) console.debug('[table] Stop value changes on row path {' + def.formPath + '}');
+      def.subscription.unsubscribe();
+      def.subscription = null;
+    }
+    if (destroy && def.subject) {
+      def.subject.complete();
+      def.subject.unsubscribe();
+    }
+  }
+}