@sumaris-net/ngx-components 1.2.8 → 1.2.14

package/src/app/core/table/entities-table-datasource.class.d.ts

@@ -1,39 +1,46 @@
-import { TableDataSource, TableElement, ValidatorService } from '@e-is/ngx-material-table';
+import { TableDataSource, TableDataSourceConfig, TableElement, ValidatorService } from '@e-is/ngx-material-table';
 import { BehaviorSubject, Observable, Subject } from 'rxjs';
 import { Entity, IEntity } from '../services/model/entity.model';
 import { OnDestroy } from '@angular/core';
 import { SortDirection } from '@angular/material/sort';
 import { CollectionViewer } from '@angular/cdk/collections';
-import { TableDataSourceOptions } from '@e-is/ngx-material-table/src/app/ngx-material-table/table-data-source';
-import { EntitiesServiceWatchOptions, IEntitiesService, LoadResult } from '../../shared/services/entity-service.class';
-export declare interface AppTableDataServiceOptions<O extends EntitiesServiceWatchOptions = EntitiesServiceWatchOptions> extends EntitiesServiceWatchOptions {
-    [key: string]: any;
+import { EntitiesServiceWatchOptions, FetchMoreFn, IEntitiesService, LoadResult } from '../../shared/services/entity-service.class';
+import { IEntitiesTableDataSource } from './table.model';
+import * as i0 from "@angular/core";
+export interface EntitiesTableDataSourceConfig<T extends Entity<T, ID>, ID = number, WO extends EntitiesServiceWatchOptions = EntitiesServiceWatchOptions, SO = any> extends TableDataSourceConfig {
+    onRowCreated?: (row: TableElement<T>) => Promise<void> | void;
     saveOnlyDirtyRows?: boolean;
+    saveBeforeDelete?: boolean;
     readOnly?: boolean;
-}
-export declare class AppTableDataSourceOptions<T extends Entity<T, ID>, ID = number, O extends EntitiesServiceWatchOptions = EntitiesServiceWatchOptions> implements TableDataSourceOptions {
+    /**
+     * @deprecated
+     */
+    dataServiceOptions?: WO & SO;
+    watchAllOptions?: WO;
+    saveAllOptions?: SO;
     [key: string]: any;
-    prependNewElements?: boolean;
-    suppressErrors?: boolean;
-    keepOriginalDataAfterConfirm?: boolean;
-    onRowCreated?: (row: TableElement<T>) => Promise<void> | void;
-    dataServiceOptions?: AppTableDataServiceOptions<O>;
-    debug?: boolean;
 }
-export declare class EntitiesTableDataSource<T extends IEntity<T, ID>, F = any, ID = number, O extends EntitiesServiceWatchOptions = EntitiesServiceWatchOptions> extends TableDataSource<T> implements OnDestroy {
-    readonly dataService: IEntitiesService<T, F, O>;
-    private readonly _logTypeName;
-    private readonly _options;
-    protected readonly _debug: boolean;
+export declare class EntitiesTableDataSource<T extends IEntity<T, ID>, F = any, ID = number, WO extends EntitiesServiceWatchOptions = EntitiesServiceWatchOptions, SO = any, V extends ValidatorService = ValidatorService, C extends EntitiesTableDataSourceConfig<T, ID, WO, SO> = EntitiesTableDataSourceConfig<T, ID, WO, SO>, R extends TableElement<T> = TableElement<T>> extends TableDataSource<T, V, C, R> implements IEntitiesTableDataSource<R>, OnDestroy {
+    readonly dataService: IEntitiesService<T, F, WO>;
+    private readonly _entityName;
+    protected _debug: boolean;
     protected _creating: boolean;
     protected _saving: boolean;
-    protected _useValidator: boolean;
-    protected _stopWatching$: Subject<any>;
-    protected _editingRowCount: number;
+    protected _fetchMoreFn: FetchMoreFn<LoadResult<T>>;
+    protected _stopWatchSubject: Subject<void>;
     loadingSubject: BehaviorSubject<boolean>;
-    get serviceOptions(): AppTableDataServiceOptions<O>;
-    set serviceOptions(value: AppTableDataServiceOptions<O>);
-    get options(): AppTableDataSourceOptions<T, ID, O>;
+    /**
+     * @deprecated Use watchAllOptions or saveAllOptions
+     */
+    get serviceOptions(): WO & SO;
+    /**
+     * @deprecated Use watchAllOptions or saveAllOptions
+     */
+    set serviceOptions(value: WO & SO);
+    get watchAllOptions(): WO;
+    set watchAllOptions(value: WO);
+    get saveAllOptions(): SO;
+    set saveAllOptions(value: SO);
     get loaded(): boolean;
     get loading(): boolean;
     /**
@@ -45,27 +52,43 @@ export declare class EntitiesTableDataSource<T extends IEntity<T, ID>, F = any,
      * @param validatorService Service that create instances of the FormGroup used to validate row fields.
      * @param config Additional configuration for table.
      */
-    constructor(dataType: new () => T, dataService: IEntitiesService<T, F, O>, validatorService?: ValidatorService, config?: AppTableDataSourceOptions<T, ID, O>);
+    constructor(dataType: new () => T, dataService: IEntitiesService<T, F, WO>, validatorService?: V, options?: C);
+    /**
+     * @deprecated use disconnect
+     */
     ngOnDestroy(): void;
+    /**
+     * @deprecated use disconnect
+     */
+    close(): void;
     watchAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: Partial<F>): Observable<LoadResult<T>>;
+    protected updateDatasourceFromRows(rows: R[]): void;
     save(): Promise<boolean>;
     updateDatasource(data: T[], opts?: {
         emitEvent: boolean;
     }): void;
-    createNew(insertAt?: number): void;
-    connect(collectionViewer: CollectionViewer): Observable<TableElement<T>[] | ReadonlyArray<TableElement<T>>>;
+    connect(collectionViewer: CollectionViewer): Observable<R[] | ReadonlyArray<R>>;
     disconnect(collectionViewer?: CollectionViewer): void;
     waitIdle(debounceTimeMs?: number): Promise<any>;
-    confirmCreate(row: TableElement<T>): boolean;
-    confirmEdit(row: TableElement<T>): boolean;
-    startEdit(row: TableElement<T>): void;
-    cancelOrDelete(row: TableElement<T>): void;
+    confirmCreate(row: R): boolean;
+    confirmEdit(row: R): boolean;
+    startEdit(row: R): boolean;
     handleError(error: any, message: string): Observable<LoadResult<T>>;
-    handleErrorPromise(error: any): void;
-    delete(id: number): void;
-    deleteAll(rows: TableElement<T>[]): Promise<any>;
-    getRows(): Promise<TableElement<T>[]>;
-    asyncCreateNew(insertAt?: number): Promise<void>;
+    handleServiceError(error: any): void;
+    delete(id: number): boolean;
+    deleteAll(rows: R[]): Promise<any>;
+    getRow(id: number): R;
+    getRows(): R[];
+    hasSomeEditingRow(): boolean;
+    createNew(insertAt?: number, opts?: {
+        editing: boolean;
+    }): Promise<R | undefined>;
+    getData(): T[];
+    fetchMore(opts?: {
+        emitEvent: boolean;
+    }): Promise<boolean>;
     markAsLoading(): void;
     markAsLoaded(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntitiesTableDataSource<any, any, any, any, any, any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EntitiesTableDataSource<any, any, any, any, any, any, any, any>, never, never, {}, {}, never, never, false>;
 }

package/src/app/core/table/memory-table.class.d.ts

@@ -1,11 +1,11 @@
 import { Injector } from '@angular/core';
 import { ValidatorService } from '@e-is/ngx-material-table';
-import { AppTableDataSourceOptions } from './entities-table-datasource.class';
+import { EntitiesTableDataSourceConfig } from './entities-table-datasource.class';
 import { AppTable } from './table.class';
 import { IEntity } from '../services/model/entity.model';
 import { InMemoryEntitiesService } from '../../shared/services/memory-entity-service.class';
+import * as i0 from "@angular/core";
 export declare abstract class AppInMemoryTable<T extends IEntity<T, ID>, F = any, ID = number> extends AppTable<T, F, ID> {
-    protected injector: Injector;
     protected columns: string[];
     protected dataType: new () => T;
     protected memoryDataService: InMemoryEntitiesService<T, F, ID>;
@@ -14,10 +14,12 @@ export declare abstract class AppInMemoryTable<T extends IEntity<T, ID>, F = any
     canDelete: boolean;
     set value(data: T[]);
     get value(): T[];
-    protected constructor(injector: Injector, columns: string[], dataType: new () => T, memoryDataService: InMemoryEntitiesService<T, F, ID>, validatorService: ValidatorService, options?: AppTableDataSourceOptions<T, ID>, filter?: F);
+    protected constructor(injector: Injector, columns: string[], dataType: new () => T, memoryDataService: InMemoryEntitiesService<T, F, ID>, validatorService: ValidatorService, options?: EntitiesTableDataSourceConfig<T, ID>, filter?: F);
     ngOnInit(): void;
     setValue(value: T[], opts?: {
         emitEvent?: boolean;
     }): void;
     protected equals(t1: T, t2: T): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppInMemoryTable<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AppInMemoryTable<any, any, any>, never, never, { "canEdit": "canEdit"; "canDelete": "canDelete"; }, {}, never, never, false>;
 }

package/src/app/core/table/table-select-columns.component.d.ts

@@ -1,5 +1,6 @@
 import { OnInit } from '@angular/core';
 import { ModalController, NavParams } from '@ionic/angular';
+import * as i0 from "@angular/core";
 export declare interface ColumnItem {
     name?: string;
     label: string;
@@ -13,11 +14,9 @@ export declare class TableSelectColumnsComponent implements OnInit {
     canHideColumns: boolean;
     constructor(navParams: NavParams, viewCtrl: ModalController);
     ngOnInit(): void;
-    onRenderItems(event: CustomEvent<{
-        from: number;
-        to: number;
-        complete: () => {};
-    }>): void;
+    onRenderItems(event: any): void;
     close(): void;
     cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableSelectColumnsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableSelectColumnsComponent, "table-select-columns", never, { "columns": "columns"; "canHideColumns": "canHideColumns"; }, {}, never, never, false>;
 }

package/src/app/core/table/table.class.d.ts

@@ -7,50 +7,23 @@ import { TableElement } from '@e-is/ngx-material-table';
 import { EntitiesTableDataSource } from './entities-table-datasource.class';
 import { SelectionModel } from '@angular/cdk/collections';
 import { IEntity } from '../services/model/entity.model';
-import { AlertController, ModalController, Platform, ToastController } from '@ionic/angular';
+import { AlertController, ModalController, ToastController } from '@ionic/angular';
 import { ActivatedRoute, Router } from '@angular/router';
 import { ColumnItem } from './table-select-columns.component';
 import { Location } from '@angular/common';
 import { IAppForm } from '../form/form.utils';
 import { LocalSettingsService } from '../services/local-settings.service';
 import { TranslateService } from '@ngx-translate/core';
-import { PlatformService } from '../services/platform.service';
-import { MatAutocompleteConfigHolder, MatAutocompleteFieldAddOptions, MatAutocompleteFieldConfig } from '../../shared/material/autocomplete/material.autocomplete';
+import { MatAutocompleteConfigHolder, MatAutocompleteFieldAddOptions, MatAutocompleteFieldConfig } from '../../shared/material/autocomplete/material.autocomplete.config';
 import { CompletableEvent } from '../../shared/events';
 import { WaitForOptions } from '../../shared/observables';
-import { ShowToastOptions } from '../../shared/toasts';
+import { ShowToastOptions } from '../../shared/toast/toasts';
 import { CdkColumnDef } from '@angular/cdk/table';
 import { LoadResult } from '../../shared/services/entity-service.class';
 import { FormErrorTranslator, FormErrorTranslatorOptions, IFormControlPathTranslator } from '../../shared/validator/form-error-adapter.class';
-export declare const SETTINGS_DISPLAY_COLUMNS = "displayColumns";
-export declare const SETTINGS_SORTED_COLUMN = "sortedColumn";
-export declare const SETTINGS_FILTER = "filter";
-export declare const SETTINGS_PAGE_SIZE = "pageSize";
-export declare const DEFAULT_PAGE_SIZE = 20;
-export declare const DEFAULT_PAGE_SIZE_OPTIONS: number[];
-export declare const RESERVED_START_COLUMNS: string[];
-export declare const RESERVED_END_COLUMNS: string[];
-export declare const DEFAULT_REQUIRED_COLUMNS: string[];
-export declare class CellValueChangeListener {
-    subject: Subject<any>;
-    subscription: Subscription;
-    formPath: string;
-    emitInitialValue: boolean;
-}
-export interface IModalDetailOptions<T = any> {
-    isNew: boolean;
-    data: T;
-    disabled: boolean;
-    onDelete?: (event: UIEvent, data: T) => Promise<boolean>;
-}
-export declare type SaveActionType = 'delete' | 'sort' | 'filter';
+import { SaveActionType } from './table.model';
+import * as i0 from "@angular/core";
 export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = number> implements OnInit, OnDestroy, AfterViewInit, IAppForm, IFormControlPathTranslator {
-    protected route: ActivatedRoute;
-    protected router: Router;
-    protected platform: Platform | PlatformService;
-    protected location: Location;
-    protected modalCtrl: ModalController;
-    protected settings: LocalSettingsService;
     protected columns: string[];
     protected _dataSource?: EntitiesTableDataSource<T, F, ID>;
     private _filter?;
@@ -59,40 +32,50 @@ export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = n
     private _dataSourceLoadingSubscription;
     private _cellValueChangesDefs;
     protected _enabled: boolean;
-    protected _destroy$: Subject<unknown>;
     protected _autocompleteConfigHolder: MatAutocompleteConfigHolder;
     protected allowRowDetail: boolean;
+    protected route: ActivatedRoute;
+    protected router: Router;
+    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: Subject<void>;
     excludesColumns: string[];
     displayedColumns: string[];
     totalRowCount: number | null;
     visibleRowCount: number;
     errorTranslatorOptions: FormErrorTranslatorOptions;
-    readySubject: BehaviorSubject<boolean>;
-    loadingSubject: BehaviorSubject<boolean>;
-    savingSubject: BehaviorSubject<boolean>;
-    dirtySubject: BehaviorSubject<boolean>;
-    errorSubject: BehaviorSubject<string>;
+    readonly readySubject: BehaviorSubject<boolean>;
+    readonly loadingSubject: BehaviorSubject<boolean>;
+    readonly savingSubject: BehaviorSubject<boolean>;
+    readonly touchedSubject: BehaviorSubject<boolean>;
+    readonly dirtySubject: BehaviorSubject<boolean>;
+    readonly errorSubject: BehaviorSubject<string>;
     get error(): string;
-    get error$(): Observable<string>;
     /**
      * @deprecated
-     * @param error
      */
+    get error$(): Observable<string>;
     set error(error: string);
+    /**
+     * @deprecated
+     */
     get loading$(): Observable<boolean>;
+    /**
+     * @deprecated
+     */
     get saving$(): Observable<boolean>;
-    isRateLimitReached: boolean;
     selection: SelectionModel<TableElement<T>>;
     editedRow: TableElement<T>;
     autocompleteFields: {
         [key: string]: MatAutocompleteFieldConfig;
     };
-    mobile: boolean;
+    readonly mobile: boolean;
     settingsId: string;
     debug: boolean;
     i18nColumnPrefix: string;
@@ -122,10 +105,7 @@ export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = n
     get filter(): F;
     get empty(): boolean;
     onRefresh: EventEmitter<any>;
-    onOpenRow: EventEmitter<{
-        id?: ID;
-        row: TableElement<T>;
-    }>;
+    onOpenRow: EventEmitter<TableElement<T>>;
     onNewRow: EventEmitter<any>;
     onStartEditingRow: EventEmitter<TableElement<T>>;
     onConfirmEditCreateRow: EventEmitter<TableElement<T>>;
@@ -151,6 +131,8 @@ export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = n
     get valid(): boolean;
     get invalid(): boolean;
     get pending(): boolean;
+    get touched(): boolean;
+    get untouched(): boolean;
     disable(opts?: {
         onlySelf?: boolean;
         emitEvent?: boolean;
@@ -160,7 +142,7 @@ export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = n
         emitEvent?: boolean;
     }): void;
     get enabled(): boolean;
-    set disabled(disabled: boolean);
+    set disabled(value: boolean);
     get disabled(): boolean;
     markAsDirty(opts?: {
         onlySelf?: boolean;
@@ -197,10 +179,6 @@ export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = n
     markAsLoaded(opts?: {
         emitEvent?: boolean;
     }): void;
-    protected markRowAsDirty(row?: TableElement<T>, opts?: {
-        onlySelf?: boolean;
-        emitEVent?: boolean;
-    }): void;
     markAsReady(opts?: {
         emitEvent?: boolean;
     }): void;
@@ -216,10 +194,11 @@ export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = n
     private _paginator;
     set paginator(value: MatPaginator);
     get paginator(): MatPaginator;
+    get destroyed(): boolean;
     table: MatTable<T>;
     childPaginator: MatPaginator;
     sort: MatSort;
-    protected constructor(route: ActivatedRoute, router: Router, platform: Platform | PlatformService, location: Location, modalCtrl: ModalController, settings: LocalSettingsService, columns: string[], _dataSource?: EntitiesTableDataSource<T, F, ID>, _filter?: F, injector?: Injector);
+    protected constructor(injector: Injector, columns: string[], _dataSource?: EntitiesTableDataSource<T, F, ID>, _filter?: F);
     ngOnInit(): void;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
@@ -231,14 +210,11 @@ export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = n
     addColumnDef(column: CdkColumnDef): void;
     removeColumnDef(column: CdkColumnDef): void;
     setFilter(filter: F, opts?: {
-        emitEvent: boolean;
+        emitEvent?: boolean;
     }): void;
-    confirmAndAdd(event?: Event, row?: TableElement<T>): boolean;
+    confirmAndAdd(event?: Event, row?: TableElement<T>): Promise<boolean>;
     confirmAndBackward(event?: Event, row?: TableElement<T>): boolean;
-    confirmAndForward(event?: Event, row?: TableElement<T>): boolean;
-    editRowById(event: Event | undefined, id: number, opts?: {
-        focusColumn?: string;
-    }): Promise<void>;
+    confirmAndForward(event?: Event, row?: TableElement<T>): boolean | Promise<boolean>;
     /**
      * Confirm the creation of the given row, or if not specified the currently edited row
      *
@@ -250,7 +226,10 @@ export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = n
         interactive?: boolean;
         keepEditing?: boolean;
     }): void;
-    addRow(event?: Event, insertAt?: number): boolean;
+    addRow(event?: Event, insertAt?: number, opts?: {
+        focusColumn?: string;
+        editing?: boolean;
+    }): Promise<boolean>;
     save(opts?: {
         keepEditing?: boolean;
     }): Promise<boolean>;
@@ -264,14 +243,17 @@ export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = n
     isAllSelected(): boolean;
     /** Selects all rows if they are not all selected; otherwise clear selection. */
     masterToggle(): Promise<void>;
-    deleteSelection(event: UIEvent): Promise<number>;
+    deleteSelection(event: Event, opts?: {
+        interactive?: boolean;
+    }): Promise<number>;
     /**
      *
      * @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
      */
-    deleteRow(event: UIEvent | null, row: TableElement<T>, opts?: {
+    deleteRow(event: Event | null, row: TableElement<T>, opts?: {
         interactive?: boolean;
     }): Promise<boolean>;
     /**
@@ -279,8 +261,9 @@ export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = n
      * @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
      */
-    deleteRows(event: UIEvent | null, rows: TableElement<T>[], opts?: {
+    deleteRows(event: Event | null, rows: TableElement<T>[], opts?: {
         interactive?: boolean;
     }): Promise<number>;
     selectRowById(id: number): Promise<boolean>;
@@ -289,9 +272,9 @@ export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = n
      * @param data
      */
     selectRowByData(data: T): Promise<boolean>;
-    clickRow(event: UIEvent | undefined, row: TableElement<T>): boolean;
+    clickRow(event: Event | undefined, row: TableElement<T>): boolean;
     moveRow(id: number, direction: number): void;
-    ready(): Promise<void>;
+    ready(opts?: WaitForOptions): Promise<void>;
     waitIdle(opts?: WaitForOptions): Promise<void>;
     openSelectColumnsModal(event?: Event): Promise<any>;
     trackByFn(index: number, row: TableElement<T>): number;
@@ -321,7 +304,7 @@ export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = n
     }): Promise<boolean>;
     protected saveBeforeAction(saveAction: SaveActionType): Promise<boolean>;
     /**
-     * Open a row. By default, will to open row detail page.
+     * Open a row detail view. By default, will to open row detail page.
      * Can be override by subclasses, BUT prefer to subscribe on onOpenRow
      * @param id
      * @param row
@@ -342,10 +325,14 @@ export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = n
     protected updateColumns(): void;
     protected registerSubscription(sub: Subscription): void;
     protected unregisterSubscription(sub: Subscription): void;
-    protected registerAutocompleteField(fieldName: string, options?: MatAutocompleteFieldAddOptions): MatAutocompleteFieldConfig;
+    protected registerAutocompleteField<E = any, EF = any>(fieldName: string, options?: MatAutocompleteFieldAddOptions<E, EF>): MatAutocompleteFieldConfig<E, EF>;
     protected getI18nColumnName(columnName: string): string;
     protected generateTableId(): string;
-    protected addRowToTable(insertAt?: number): Promise<TableElement<T>>;
+    protected addRowToTable(insertAt?: number, opts?: {
+        focusColumn?: string;
+        editing?: boolean;
+        emitEvent?: boolean;
+    }): Promise<TableElement<T> | undefined>;
     protected registerCellValueChanges(name: string, formPath?: string, emitInitialValue?: boolean): Observable<any>;
     protected setShowColumn(columnName: string, show: boolean, opts?: {
         emitEvent?: boolean;
@@ -353,9 +340,9 @@ export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = n
     protected getShowColumn(columnName: string): boolean;
     protected startsWithUpperCase(input: string, search: string): boolean;
     protected markForCheck(): void;
-    protected askDeleteConfirmation(event?: UIEvent, rows?: TableElement<T>[]): Promise<boolean>;
-    protected askCancelConfirmation(event?: UIEvent, rows?: TableElement<T>[]): Promise<boolean>;
-    protected askRestoreConfirmation(event?: UIEvent): Promise<boolean>;
+    protected askDeleteConfirmation(event?: Event, rows?: TableElement<T>[]): Promise<boolean>;
+    protected askCancelConfirmation(event?: Event, rows?: TableElement<T>[]): Promise<boolean>;
+    protected askRestoreConfirmation(event?: Event): Promise<boolean>;
     protected showToast(opts: ShowToastOptions): Promise<import("@ionic/core").OverlayEventDetail<any>>;
     protected resetError(opts?: {
         emitEvent?: boolean;
@@ -373,12 +360,22 @@ export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = n
      * @protected
      */
     protected equals(d1: T, d2: T): boolean;
+    protected markRowAsDirty(row?: TableElement<T>, opts?: {
+        onlySelf?: boolean;
+        emitEVent?: boolean;
+    }): void;
+    private listenSortAndPaginationEvents;
+    private editRowById;
     private setLoading;
     private deleteNewRow;
+    private deleteExistingRow;
     private cancelExistingRow;
+    private checkIfRowPristine;
     private checkIfPristine;
     private applyFilter;
     private listenDatasourceLoading;
     private startCellValueChanges;
     private stopCellValueChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppTable<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AppTable<any, any, any>, never, never, { "settingsId": "settingsId"; "debug": "debug"; "i18nColumnPrefix": "i18nColumnPrefix"; "i18nColumnSuffix": "i18nColumnSuffix"; "autoLoad": "autoLoad"; "readOnly": "readOnly"; "inlineEdition": "inlineEdition"; "focusFirstColumn": "focusFirstColumn"; "confirmBeforeDelete": "confirmBeforeDelete"; "confirmBeforeCancel": "confirmBeforeCancel"; "undoableDeletion": "undoableDeletion"; "saveBeforeDelete": "saveBeforeDelete"; "keepEditedRowOnSave": "keepEditedRowOnSave"; "saveBeforeSort": "saveBeforeSort"; "saveBeforeFilter": "saveBeforeFilter"; "propagateRowError": "propagateRowError"; "defaultSortBy": "defaultSortBy"; "defaultSortDirection": "defaultSortDirection"; "defaultPageSize": "defaultPageSize"; "defaultPageSizeOptions": "defaultPageSizeOptions"; "focusColumn": "focusColumn"; "dataSource": "dataSource"; "filter": "filter"; "disabled": "disabled"; "paginator": "paginator"; }, { "onRefresh": "onRefresh"; "onOpenRow": "onOpenRow"; "onNewRow": "onNewRow"; "onStartEditingRow": "onStartEditingRow"; "onConfirmEditCreateRow": "onConfirmEditCreateRow"; "onCancelOrDeleteRow": "onCancelOrDeleteRow"; "onBeforeDeleteRows": "onBeforeDeleteRows"; "onBeforeCancelRows": "onBeforeCancelRows"; "onBeforeSave": "onBeforeSave"; "onAfterDeletedRows": "onAfterDeletedRows"; "onSort": "onSort"; "onDirty": "onDirty"; "onError": "onError"; }, never, never, false>;
 }

package/src/app/core/table/table.model.d.ts

@@ -0,0 +1,26 @@
+import { Subject, Subscription } from 'rxjs';
+export declare const SETTINGS_DISPLAY_COLUMNS = "displayColumns";
+export declare const SETTINGS_SORTED_COLUMN = "sortedColumn";
+export declare const SETTINGS_FILTER = "filter";
+export declare const SETTINGS_PAGE_SIZE = "pageSize";
+export declare const DEFAULT_PAGE_SIZE = 20;
+export declare const DEFAULT_PAGE_SIZE_OPTIONS: number[];
+export declare const RESERVED_START_COLUMNS: string[];
+export declare const RESERVED_END_COLUMNS: string[];
+export declare const DEFAULT_REQUIRED_COLUMNS: string[];
+export declare class CellValueChangeListener {
+    subject: Subject<any>;
+    subscription: Subscription;
+    formPath: string;
+    emitInitialValue: boolean;
+}
+export interface IModalDetailOptions<T = any> {
+    isNew: boolean;
+    data: T;
+    disabled: boolean;
+    onDelete?: (event: Event, data: T) => Promise<boolean>;
+}
+export declare type SaveActionType = 'delete' | 'sort' | 'filter';
+export interface IEntitiesTableDataSource<R> {
+    getRows(): R[];
+}

package/src/app/core/table/table.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./table-select-columns.component";
+import * as i2 from "./actions-column.component";
+import * as i3 from "../../shared/shared.module";
+import * as i4 from "@ngx-translate/core";
+export declare class AppTableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppTableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppTableModule, [typeof i1.TableSelectColumnsComponent, typeof i2.ActionsColumnComponent], [typeof i3.SharedModule, typeof i4.TranslateModule], [typeof i4.TranslateModule, typeof i1.TableSelectColumnsComponent, typeof i2.ActionsColumnComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppTableModule>;
+}

package/src/app/core/table/table.utils.d.ts

@@ -1,6 +1,7 @@
 import { AppTable } from './table.class';
 import { TableElement } from '@e-is/ngx-material-table';
+import { AsyncTableElement } from '@e-is/ngx-material-table/src/app/ngx-material-table/async/async-table-element';
 export declare class AppTableUtils {
     static waitIdle(table: AppTable<any, any, any>): Promise<any>;
-    static logRowErrors(row: TableElement<any>, logPrefix?: string): void;
+    static logRowErrors(row: TableElement<any> | AsyncTableElement<any>, logPrefix?: string): void;
 }

package/src/app/core/table/testing/table.testing.d.ts

@@ -0,0 +1,51 @@
+import { ChangeDetectorRef, Injector, OnDestroy, OnInit } from '@angular/core';
+import { AppTable } from '../table.class';
+import { Referential } from '../../services/model/referential.model';
+import { IonInfiniteScroll } from '@ionic/angular';
+import { InMemoryEntitiesService } from '../../../shared/services/memory-entity-service.class';
+import { AppValidatorService } from '../../services/validator/base.validator.class';
+import { AbstractControl, UntypedFormBuilder, UntypedFormGroup } from '@angular/forms';
+import { ReferentialFilter } from '../../services/testing/referential-filter.model';
+import { MatExpansionPanel } from '@angular/material/expansion';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class TableTestPage extends AppTable<Referential, ReferentialFilter> implements OnInit, OnDestroy {
+    protected validatorService: AppValidatorService;
+    protected formBuilder: UntypedFormBuilder;
+    protected cd: ChangeDetectorRef;
+    static maxRowCount: number;
+    timer: Subscription;
+    canEdit: boolean;
+    data: Referential[];
+    filterForm: UntypedFormGroup;
+    filterCriteriaCount: number;
+    groupColumns: string[];
+    readonly statusList: readonly import("../../services/model/referential.model").IStatus[];
+    readonly statusById: Readonly<import("@sumaris-net/ngx-components").KeyValueType<import("../../services/model/referential.model").IStatus>>;
+    enableInfiniteScroll: boolean;
+    useSticky: boolean;
+    get hasMoreData(): boolean;
+    filterExpansionPanel: MatExpansionPanel;
+    infiniteScroll: IonInfiniteScroll;
+    get dataService(): InMemoryEntitiesService<Referential>;
+    constructor(injector: Injector, validatorService: AppValidatorService, formBuilder: UntypedFormBuilder, cd: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected restoreFilter(): void;
+    toggleTimer(): void;
+    load(): void;
+    fetchMore(event: any): Promise<void>;
+    save(opts?: {
+        keepEditing?: boolean;
+    }): Promise<boolean>;
+    clearControlValue(event: Event, formControl: AbstractControl): boolean;
+    applyFilterAndClosePanel(event?: Event): void;
+    resetFilter(event?: Event): void;
+    startTimer(): void;
+    stopTimer(): void;
+    protected generateData(offset?: number, size?: number): Referential[];
+    protected markForCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableTestPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableTestPage, "app-table-testing", never, { "enableInfiniteScroll": "enableInfiniteScroll"; "useSticky": "useSticky"; }, {}, never, never, false>;
+}

package/src/app/core/table/testing/table.testing.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./table.testing";
+import * as i2 from "@angular/common";
+import * as i3 from "../../../shared/shared.module";
+import * as i4 from "../../core.module";
+import * as i5 from "@ngx-translate/core";
+export declare class TableTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TableTestingModule, [typeof i1.TableTestPage], [typeof i2.CommonModule, typeof i3.SharedModule, typeof i4.CoreModule, typeof i5.TranslateModule], [typeof i1.TableTestPage, typeof i5.TranslateModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TableTestingModule>;
+}

package/src/app/shared/alerts.d.ts

@@ -9,7 +9,7 @@ export declare class Alerts {
      * @param event
      * @deprecated prefer ComponentDirtyGuard
      */
-    static askSaveBeforeLeave(alertCtrl: AlertController, translate: TranslateService, event?: UIEvent): Promise<boolean | undefined>;
+    static askSaveBeforeLeave(alertCtrl: AlertController, translate: TranslateService, event?: Event): Promise<boolean | undefined>;
     /**
      * Ask the user to conform an action. If return undefined: user has cancelled
      *
@@ -19,7 +19,7 @@ export declare class Alerts {
      * @param event
      * @param interpolateParams
      */
-    static askActionConfirmation(alertCtrl: AlertController, translate: TranslateService, immediate?: boolean, event?: UIEvent, interpolateParams?: any): Promise<boolean | undefined>;
+    static askActionConfirmation(alertCtrl: AlertController, translate: TranslateService, immediate?: boolean, event?: Event, interpolateParams?: any): Promise<boolean | undefined>;
     /**
      * Ask the user to confirm. If return undefined: user has cancelled
      *
@@ -30,7 +30,7 @@ export declare class Alerts {
      * @param event
      * @param interpolateParams
      */
-    static askConfirmation(messageKey: string, alertCtrl: AlertController, translate: TranslateService, event?: UIEvent, interpolateParams?: any): Promise<boolean | undefined>;
+    static askConfirmation(messageKey: string, alertCtrl: AlertController, translate: TranslateService, event?: Event, interpolateParams?: any): Promise<boolean | undefined>;
     /**
      * Ask the user to save before leaving. If return undefined: user has cancelled
      *
@@ -39,7 +39,7 @@ export declare class Alerts {
      * @param event
      * @param interpolateParams
      */
-    static askDeleteConfirmation(alertCtrl: AlertController, translate: TranslateService, event?: UIEvent, interpolateParams?: any): Promise<boolean | undefined>;
+    static askDeleteConfirmation(alertCtrl: AlertController, translate: TranslateService, event?: Event, interpolateParams?: any): Promise<boolean | undefined>;
     static askSaveBeforeAction(alertCtrl: AlertController, translate: TranslateService, event?: {
         valid: boolean;
     }, interpolateParams?: any): Promise<{