@sumaris-net/ngx-components 2.3.5 → 2.4.0-rc1

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

@@ -140,7 +140,7 @@ import { isDataSource, SelectionModel } from '@angular/cdk/collections';
 import { Camera, CameraResultType } from '@capacitor/camera';
 import { Geolocation } from '@capacitor/geolocation';
 import * as i3$2 from '@e-is/ngx-material-table';
-import { ValidatorService, TableDataSource } from '@e-is/ngx-material-table';
+import { ValidatorService, TableDataSource, AsyncTableDataSource } from '@e-is/ngx-material-table';
 
 const ENVIRONMENT = new InjectionToken('ENV');
 class Environment {
@@ -6424,7 +6424,7 @@ class MatDateTime {
         }
         else {
             // Reset hour
-            const day = date.startOf('day');
+            const day = date.clone().startOf('day');
             const dayStr = this.dateAdapter.format(day, this.dayPattern);
             // Format time
             let timeStr;
@@ -25546,6 +25546,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImpo
             type: Directive
         }], ctorParameters: function () { return [{ type: GraphqlService }, { type: PlatformService }, { type: undefined }, { type: undefined }, { type: undefined }]; } });
 
+const SETTINGS_DISPLAY_COLUMNS = 'displayColumns';
+const SETTINGS_SORTED_COLUMN = 'sortedColumn';
+const SETTINGS_FILTER = 'filter';
+const SETTINGS_PAGE_SIZE = 'pageSize';
+const DEFAULT_PAGE_SIZE = 20;
+const DEFAULT_PAGE_SIZE_OPTIONS = [20, 50, 100, 200, 500];
+const RESERVED_START_COLUMNS = ['select', 'id'];
+const RESERVED_END_COLUMNS = ['actions'];
+const DEFAULT_REQUIRED_COLUMNS = ['id'];
+class CellValueChangeListener {
+}
+
 class AppTableUtils {
     static waitIdle(table) {
         if (!table || !table.dataSource) {
@@ -25960,17 +25972,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImpo
             type: Directive
         }], ctorParameters: function () { return [{ type: undefined }, { type: undefined }, { type: undefined }, { type: undefined }]; } });
 
-const SETTINGS_DISPLAY_COLUMNS = 'displayColumns';
-const SETTINGS_SORTED_COLUMN = 'sortedColumn';
-const SETTINGS_FILTER = 'filter';
-const SETTINGS_PAGE_SIZE = 'pageSize';
-const DEFAULT_PAGE_SIZE = 20;
-const DEFAULT_PAGE_SIZE_OPTIONS = [20, 50, 100, 200, 500];
-const RESERVED_START_COLUMNS = ['select', 'id'];
-const RESERVED_END_COLUMNS = ['actions'];
-const DEFAULT_REQUIRED_COLUMNS = ['id'];
-class CellValueChangeListener {
-}
 // @dynamic
 // eslint-disable-next-line @angular-eslint/directive-class-suffix
 class AppTable {
@@ -28526,9 +28527,10 @@ class AppEntityEditor extends AppTabEditor {
         this._listenChangesSubscription = this.listenChanges(this.data.id, {
             interval: this._listenIntervalInSeconds
         })
-            .pipe(filter(isNotNil), 
-        // If saving, wait end, to avoid to detect self changes
-        mergeMap((data) => this.saving ? of(data) : firstFalse(this.savingSubject).pipe(mapTo(data))))
+            .pipe(filter(isNotNil), mergeMap((data) => this.saving
+            // If saving, wait end, to avoid to detect self changes
+            ? firstFalse(this.savingSubject).pipe(mapTo(data), debounceTime(500))
+            : of(data)))
             .subscribe((data) => {
             const isNewer = isMoment(data.updateDate) && data.updateDate.isAfter(this.data.updateDate);
             if (!isNewer)
@@ -29439,6 +29441,2082 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImpo
                 type: Input
             }] } });
 
+// @dynamic
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+class EntitiesAsyncTableDataSource extends AsyncTableDataSource {
+    /**
+     * Creates a new TableDataSource instance, that can be used as datasource of `@angular/cdk` data-table.
+     *
+     * @param dataService A service to load and save data
+     * @param dataType Type of data contained by the Table. If not specified, then `data` with at least one element must be specified.
+     * @param environment
+     * @param validatorService Service that create instances of the FormGroup used to validate row fields.
+     * @param config Additional configuration for table.
+     */
+    constructor(dataType, dataService, validatorService, options) {
+        super([], dataType, validatorService, Object.assign({ keepOriginalDataAfterConfirm: false, readOnly: false, saveOnlyDirtyRows: false }, options));
+        this.dataService = dataService;
+        this._debug = false;
+        this._creating = false;
+        this._saving = false;
+        this._fetchMoreFn = null;
+        this._stopWatchSubject = new Subject();
+        this.loadingSubject = new BehaviorSubject(undefined);
+        this._entityName = removeEnd((new dataType()).__typename || 'UnknownVO', 'VO');
+        this._debug = (options === null || options === void 0 ? void 0 : options.suppressErrors) === false && !environment.production;
+    }
+    get watchAllOptions() {
+        return this.config.watchAllOptions;
+    }
+    set watchAllOptions(value) {
+        this.config.watchAllOptions = value;
+    }
+    get saveAllOptions() {
+        return this.config.saveAllOptions;
+    }
+    set saveAllOptions(value) {
+        this.config.saveAllOptions = value;
+    }
+    get loaded() {
+        return this.loadingSubject.value === false; // Should be false when undefined (initial state)
+    }
+    get loading() {
+        return this.loadingSubject.value !== false; // Should be true when undefined (initial state)
+    }
+    ngOnDestroy() {
+        this.disconnect();
+    }
+    watchAll(offset, size, sortBy, sortDirection, filter) {
+        this._stopWatchSubject.next();
+        this._fetchMoreFn = null;
+        this.markAsLoading();
+        return this.dataService.watchAll(offset, size, sortBy, sortDirection, filter, this.watchAllOptions)
+            .pipe(catchError(err => this.handleError(err, 'ERROR.LOAD_DATA_ERROR')), map((res) => {
+            if (this._saving) {
+                console.info(`[entities-table-datasource] Received ${this._entityName} data (from service), but still saving: skip`);
+            }
+            else if (this.hasSomeEditingRow()) {
+                console.warn(`[entities-table-datasource] Received ${this._entityName} data, while some row still editing: skip; Please check save() implementation in the table!`);
+            }
+            else {
+                this.updateDatasource((res.data || []));
+                this._fetchMoreFn = res.fetchMore;
+            }
+            return res;
+        }), 
+        // Stop this pipe next time we call watchAll()
+        takeUntil(this._stopWatchSubject)
+        // ⚠ Notice: Don't put any operator after takeUntil to avoid potential subscription leaks
+        );
+    }
+    updateDatasourceFromRows(rows) {
+        var _a;
+        // Avoid to update dataSourceSubject, when not need
+        if ((_a = this.datasourceSubject.observers) === null || _a === void 0 ? void 0 : _a.length) {
+            if (!this.config.suppressErrors)
+                console.warn('[entities-table-datasource] Update datasource subject. Please prefer using \'rowsSubject\' instead of \'datasourceSubject\'');
+            super.updateDatasourceFromRows(rows);
+        }
+        else {
+            console.debug('[entities-table-datasource] Skipping datasourceSubject update (not used yet).');
+        }
+    }
+    save() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.config.readOnly) {
+                console.error('[entities-table-datasource] Enable to save, because config.readOnly=true');
+                return false;
+            }
+            // Saving twice (should never occur)
+            if (this._saving) {
+                console.warn(`[entities-table-datasource] Trying to save ${this._entityName} rows twice. Skip`);
+                return false;
+            }
+            this._saving = true;
+            this.markAsLoading();
+            const onlyDirtyRows = this.config.saveOnlyDirtyRows;
+            try {
+                if (this._debug)
+                    console.debug(`[entities-table-datasource] Saving ${this._entityName} rows... {onlyDirtyRows: ${onlyDirtyRows}}`);
+                // Get all rows
+                const rows = this.getRows();
+                // Finish editing all rows
+                const invalidRows = (yield Promise.all(this.getEditingRows()
+                    .map(row => row.confirmEditCreate().then(confirmed => confirmed === false ? row : null))))
+                    .filter(isNotNil);
+                // Cannot finish some rows: error
+                if (invalidRows.length) {
+                    // log errors
+                    if (this._debug)
+                        invalidRows.forEach(row => AppTableUtils.logRowErrors(row, `[entities-table-datasource] ${this._entityName} row #${row.id}`));
+                    // Stop with an error
+                    throw { code: ErrorCodes.TABLE_INVALID_ROW_ERROR, message: 'ERROR.TABLE_INVALID_ROW_ERROR' };
+                }
+                let data;
+                let dataToSave;
+                if (this.validatorService) {
+                    dataToSave = [];
+                    data = rows.map(row => {
+                        const currentData = new this.dataConstructor();
+                        currentData.fromObject(row.currentData);
+                        // Filter to keep only dirty row
+                        if (onlyDirtyRows && row.validator.dirty)
+                            dataToSave.push(currentData);
+                        return currentData;
+                    });
+                    if (!onlyDirtyRows)
+                        dataToSave = data;
+                }
+                // Or use the current data without conversion (when no validator service used)
+                else {
+                    data = rows.map(row => row.currentData);
+                    // save all data, as we don't have any dirty marker
+                    dataToSave = data;
+                }
+                // If no data to save: exit
+                if (onlyDirtyRows && !dataToSave.length) {
+                    if (this._debug)
+                        console.debug(`[entities-table-datasource] No ${this._entityName} data to save. Skip`);
+                    return false;
+                }
+                if (this._debug)
+                    console.debug(`[entities-table-datasource] Asking service to save this ${this._entityName} data:`, dataToSave);
+                yield this.dataService.saveAll(dataToSave, this.saveAllOptions);
+                if (this._debug)
+                    console.debug(`[entities-table-datasource] Saving ${this._entityName} data [OK]`);
+                // LP 23/03/2021: update datasource is necessary but can be changed to a refetch() on QueryRef (must be created and registered in GraphqlService.watchQuery)
+                this.updateDatasource(data, { emitEvent: false });
+                return true;
+            }
+            catch (error) {
+                if (this._debug)
+                    console.error('[entities-table-datasource] Error while saving: ' + error && error.message || error);
+                throw error;
+            }
+            finally {
+                this._saving = false;
+                this.markAsLoaded();
+            }
+        });
+    }
+    updateDatasource(data, opts) {
+        if (this._debug)
+            console.debug(`[entities-table-datasource] Updating datasource with data:`, data);
+        super.updateDatasource(data, opts);
+        if (!opts || opts.emitEvent !== false) {
+            this.markAsLoaded();
+        }
+    }
+    connect(collectionViewer) {
+        // DEBUG
+        //console.debug("[entities-datasource] connect");
+        return super.connect(collectionViewer);
+    }
+    disconnect(collectionViewer) {
+        if (this._debug)
+            console.debug('[entities-table-datasource] Disconnecting...');
+        super.disconnect(collectionViewer);
+        if (!this._stopWatchSubject.closed) {
+            if (this._debug)
+                console.debug('[entities-table-datasource] Closing...');
+            this._stopWatchSubject.next();
+            this._stopWatchSubject.complete();
+            this._stopWatchSubject.unsubscribe();
+            this.loadingSubject.complete();
+            this.loadingSubject.unsubscribe();
+        }
+    }
+    waitIdle(debounceTimeMs) {
+        return firstFalsePromise(this.loadingSubject
+            .asObservable()
+            .pipe(debounceTime(debounceTimeMs || 100) // if not started yet, wait
+        ));
+    }
+    confirmCreate(row) {
+        const _super = Object.create(null, {
+            confirmCreate: { get: () => super.confirmCreate }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const confirmed = yield _super.confirmCreate.call(this, row);
+            if (!confirmed)
+                return false;
+            if (row.editing && row.validator) {
+                console.warn('[entities-table-datasource] Row still has {editing: true} after confirmCreate()! Force editing to false');
+                row.validator.disable({ onlySelf: true, emitEvent: false });
+            }
+            return confirmed;
+        });
+    }
+    confirmEdit(row) {
+        const _super = Object.create(null, {
+            confirmEdit: { get: () => super.confirmEdit }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const confirmed = yield _super.confirmEdit.call(this, row);
+            if (!confirmed)
+                return false;
+            if (row.editing && row.validator) {
+                console.warn('[entities-table-datasource] Row still has {editing: true} after confirmEdit()! Force editing to false');
+                row.validator.disable({ onlySelf: true, emitEvent: false });
+            }
+            return true;
+        });
+    }
+    startEdit(row) {
+        const _super = Object.create(null, {
+            startEdit: { get: () => super.startEdit }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const editing = yield _super.startEdit.call(this, row);
+            if (!editing)
+                return false;
+            if (!row.editing && row.validator) {
+                console.warn('[entities-table-datasource] Row still has {editing: false} after startEdit()! Force editing');
+                row.validator.enable({ onlySelf: true, emitEvent: false });
+            }
+            return true;
+        });
+    }
+    handleError(error, message) {
+        const errorMsg = error && error.message || error;
+        console.error(`[entities-table-datasource] Service ${this._entityName} sent error: ${errorMsg}`, error);
+        this.markAsLoaded();
+        throw new Error(message || errorMsg);
+    }
+    handleServiceError(error) {
+        const errorMsg = error && error.message || error;
+        console.error(`[entities-table-datasource] Service ${this._entityName} sent error: ${errorMsg}`, error);
+        this.markAsLoaded();
+        throw error;
+    }
+    delete(id) {
+        const _super = Object.create(null, {
+            delete: { get: () => super.delete }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            // If new row: not need to propagate to the dataService
+            if (id === -1) {
+                return _super.delete.call(this, id);
+            }
+            const row = this.getRow(id);
+            if (!row) {
+                console.error(`[entities-table-datasource] Row to delete with id=${id} not found`);
+                return;
+            }
+            this.markAsLoading();
+            try {
+                yield this.dataService.deleteAll([row.currentData], this.saveAllOptions);
+                // Wait cache update, then table update
+                yield sleep(300);
+                // make sure row has been deleted (because GraphQl cache remove can fail)
+                const present = this.getRow(id) === row;
+                if (present)
+                    yield _super.delete.call(this, id);
+                this.markAsLoaded();
+            }
+            catch (err) {
+                this.handleServiceError(err);
+            }
+        });
+    }
+    deleteAll(rows) {
+        const _super = Object.create(null, {
+            delete: { get: () => super.delete }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            this.markAsLoading();
+            const data = this.getDataFromRows(rows);
+            try {
+                // Call service deletion
+                yield this.dataService.deleteAll(data, this.saveAllOptions);
+                // Workaround, to be sure all rows have been deleted
+                // Sometime, the service miss deletion, or GraphQl cache remove failed.
+                // In this case, apply missing deletion using the parent delete() function
+                const rowNotDeleted = this.getRows().filter(row => rows.includes(row));
+                const deleteFn = _super.delete;
+                if (isNotEmptyArray(rowNotDeleted)) {
+                    console.warn(`[entities-table-datasource] Force deletion of ${rowNotDeleted.length} rows! Please check that data service update the cache, after deletion`);
+                    rowNotDeleted
+                        // Start at the end
+                        .sort((a, b) => a.id > b.id ? -1 : 1)
+                        .forEach(r => deleteFn(r.id));
+                }
+            }
+            catch (err) {
+                // Handle service error
+                this.handleServiceError(err);
+            }
+            finally {
+                this.markAsLoaded();
+            }
+        });
+    }
+    getRow(id) {
+        return super.getRow(id);
+    }
+    getRows() {
+        return this.rowsSubject.value || [];
+    }
+    getEditingRows() {
+        return this.getRows().filter(row => row.editing);
+    }
+    getSingleEditingRow() {
+        const rows = this.getRows();
+        return rows.length === 1 ? rows[0] : undefined;
+    }
+    hasSomeEditingRow() {
+        return this.getRows().some(row => row.editing);
+    }
+    createNew(insertAt, opts = { editing: true }) {
+        const _super = Object.create(null, {
+            createNew: { get: () => super.createNew }
+        });
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            // Avoid multiple call (only one editing row is allowed)
+            if (this._creating && opts.editing)
+                return;
+            this._creating = true;
+            try {
+                const row = yield _super.createNew.call(this, insertAt, opts);
+                if (!row)
+                    return undefined; // Stop here
+                // Call observers
+                if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.onRowCreated) {
+                    try {
+                        yield this.config.onRowCreated(row);
+                    }
+                    catch (err) {
+                        // Log, then continue
+                        console.error(err && err.message || err, err);
+                    }
+                }
+                return row;
+            }
+            finally {
+                this._creating = false;
+            }
+        });
+    }
+    getData() {
+        const rows = this.getRows();
+        return this.getDataFromRows(rows);
+    }
+    fetchMore(opts) {
+        const _super = Object.create(null, {
+            updateDatasource: { get: () => super.updateDatasource }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._fetchMoreFn)
+                return false; // Avoid multiple call
+            if (this.hasSomeEditingRow()) {
+                console.warn(`Cannot fetch more ${this._entityName} because some row) still editing`);
+                return;
+            }
+            console.debug(`Will fetching more row(s) still...`);
+            // Forget the fetchMore function, to avoid multiple call
+            const fetchMoreFn = this._fetchMoreFn;
+            this._fetchMoreFn = null;
+            // Fetch next page
+            const res = yield fetchMoreFn();
+            // Skip if empty (no more data)
+            if (isEmptyArray(res === null || res === void 0 ? void 0 : res.data))
+                return false;
+            // Update the data source
+            _super.updateDatasource.call(this, (this.currentData || []).concat(...res.data), opts);
+            // Remember fetchMore
+            this._fetchMoreFn = res.fetchMore;
+            return true;
+        });
+    }
+    /* -- protected method -- */
+    markAsLoading() {
+        if (this.loadingSubject.value !== true) {
+            this.loadingSubject.next(true);
+        }
+    }
+    markAsLoaded() {
+        if (this.loadingSubject.value !== false) {
+            this.loadingSubject.next(false);
+        }
+    }
+}
+EntitiesAsyncTableDataSource.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: EntitiesAsyncTableDataSource, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+EntitiesAsyncTableDataSource.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.12", type: EntitiesAsyncTableDataSource, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: EntitiesAsyncTableDataSource, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: undefined }, { type: undefined }, { type: undefined }, { type: undefined }]; } });
+
+// @dynamic
+// noinspection DuplicatedCode
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+class AppAsyncTable {
+    constructor(injector, columns, _dataSource, _filter) {
+        this.columns = columns;
+        this._dataSource = _dataSource;
+        this._filter = _filter;
+        this._initialized = false;
+        this._subscription = new Subscription();
+        this._cellValueChangesDefs = {};
+        this._enabled = true;
+        this.allowRowDetail = true;
+        this.destroySubject = new Subject();
+        this.excludesColumns = [];
+        this.totalRowCount = null;
+        this.readySubject = new BehaviorSubject(false);
+        this.loadingSubject = new BehaviorSubject(true);
+        this.savingSubject = new BehaviorSubject(false);
+        this.touchedSubject = new BehaviorSubject(false);
+        this.dirtySubject = new BehaviorSubject(false);
+        this.errorSubject = new BehaviorSubject(undefined);
+        this.selection = new SelectionModel(true, []);
+        this.i18nColumnPrefix = 'COMMON.';
+        this.autoLoad = true;
+        this.focusFirstColumn = false;
+        this.confirmBeforeDelete = false;
+        this.confirmBeforeCancel = false;
+        this.undoableDeletion = false;
+        this.propagateRowError = false;
+        this.defaultPageSize = DEFAULT_PAGE_SIZE;
+        this.defaultPageSizeOptions = DEFAULT_PAGE_SIZE_OPTIONS;
+        this.onRefresh = new EventEmitter();
+        this.onOpenRow = new EventEmitter();
+        this.onNewRow = new EventEmitter();
+        this.onStartEditingRow = new EventEmitter();
+        this.onConfirmEditCreateRow = new EventEmitter();
+        this.onCancelOrDeleteRow = new EventEmitter();
+        this.onBeforeDeleteRows = createPromiseEventEmitter();
+        this.onBeforeCancelRows = createPromiseEventEmitter();
+        this.onBeforeSave = createPromiseEventEmitter();
+        this.onAfterDeletedRows = new EventEmitter();
+        this.onSort = new EventEmitter();
+        this.onDirty = new EventEmitter();
+        this.onError = new EventEmitter();
+        this._paginator = null;
+        this.route = injector.get(ActivatedRoute);
+        this.router = injector.get(Router);
+        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;
+    }
+    get error() {
+        return this.errorSubject.value;
+    }
+    set error(error) {
+        this.setError(error);
+    }
+    get firstUserColumn() {
+        return this.displayedColumns[RESERVED_START_COLUMNS.length];
+    }
+    get lastUserColumn() {
+        return this.displayedColumns[this.displayedColumns.length - RESERVED_END_COLUMNS.length - 1];
+    }
+    set dataSource(value) {
+        this.setDatasource(value);
+    }
+    get dataSource() {
+        return this._dataSource;
+    }
+    set filter(value) {
+        this.setFilter(value);
+    }
+    get filter() {
+        return this._filter;
+    }
+    get empty() {
+        return this.loading || this.totalRowCount === 0;
+    }
+    get dirty() {
+        return this.dirtySubject.value;
+    }
+    get valid() {
+        return this.dataSource.getRows().every(row => row.editing ? row.valid : true);
+    }
+    get invalid() {
+        return this.dataSource.getRows().some(row => row.editing ? row.invalid : false);
+    }
+    get pending() {
+        return this.dataSource.getRows().some(row => row.editing ? row.pending : false);
+    }
+    get touched() {
+        return this.touchedSubject.value;
+    }
+    get untouched() {
+        return !this.touchedSubject.value;
+    }
+    disable(opts) {
+        if (this.sort)
+            this.sort.disabled = true;
+        this._enabled = false;
+        if (!opts || opts.emitEvent != false)
+            this.markForCheck();
+    }
+    enable(opts) {
+        if (this.sort)
+            this.sort.disabled = false;
+        this._enabled = true;
+        if (!opts || opts.emitEvent != false)
+            this.markForCheck();
+    }
+    get enabled() {
+        return this._enabled;
+    }
+    // FIXME: need to hidden buttons (in HTML), etc. when disabled
+    set disabled(value) {
+        if (value !== !this._enabled) {
+            if (value)
+                this.disable({ emitEvent: false });
+            else
+                this.enable({ emitEvent: false });
+        }
+    }
+    get disabled() {
+        return !this._enabled;
+    }
+    markAsDirty(opts) {
+        if (this.dirtySubject.value !== true) {
+            this.dirtySubject.next(true);
+            if (!opts || opts.emitEvent !== false) {
+                this.markForCheck();
+            }
+        }
+    }
+    markAsPristine(opts) {
+        if (this.dirtySubject.value !== false) {
+            this.dirtySubject.next(false);
+            if (!opts || opts.emitEvent !== false) {
+                this.markForCheck();
+            }
+        }
+    }
+    markAsUntouched(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let needEmitEvent = false;
+            if (this.touchedSubject.value) {
+                this.touchedSubject.next(false);
+                needEmitEvent = true;
+            }
+            if (this.dirty || this.dataSource.hasSomeEditingRow()) {
+                for (const row of this.dataSource.getEditingRows()) {
+                    // Cancel the current editing row only if editing and if it was not previously saved
+                    yield this.dataSource.cancelOrDelete(row);
+                    // Mark row as pristine
+                    yield this.checkIfRowPristine(row, { emitEvent: false });
+                }
+                needEmitEvent = true;
+            }
+            this.previouslyEditedRowId = undefined;
+            if (needEmitEvent && (!opts || opts.emitEvent !== false))
+                this.markForCheck();
+        });
+    }
+    /**
+     * @deprecated prefer to use markAllAsTouched()
+     * @param opts
+     */
+    markAsTouched(opts) {
+        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 => { var _a; return (_a = row.validator) === null || _a === void 0 ? void 0 : _a.markAllAsTouched(); });
+            if (!opts || opts.emitEvent !== false) {
+                this.markForCheck();
+            }
+        }
+    }
+    markAllAsTouched(opts) {
+        if (this.touchedSubject.value !== true) {
+            this.touchedSubject.next(true);
+            if (!opts || opts.emitEvent !== false)
+                this.markForCheck();
+        }
+        if (this.dataSource.hasSomeEditingRow()) {
+            this.dataSource.getEditingRows().forEach(row => { var _a; return (_a = row.validator) === null || _a === void 0 ? void 0 : _a.markAllAsTouched(); });
+        }
+    }
+    markAsSaving(opts) {
+        if (this.savingSubject.value !== true) {
+            this.focusColumn = undefined; // unselect focus column
+            this.savingSubject.next(true);
+            if (!opts || opts.emitEvent !== false)
+                this.markForCheck();
+        }
+    }
+    markAsSaved(opts) {
+        if (this.savingSubject.value !== false) {
+            this.savingSubject.next(false);
+            if (!opts || opts.emitEvent !== false)
+                this.markForCheck();
+        }
+    }
+    markAsLoading(opts) {
+        this.setLoading(true, opts);
+    }
+    markAsLoaded(opts) {
+        this.setLoading(false, opts);
+    }
+    markAsReady(opts) {
+        if (this.readySubject.value !== true) {
+            this.readySubject.next(true);
+            // If subclasses implements OnReady
+            if (typeof this['ngOnReady'] === 'function') {
+                this.ngOnReady();
+            }
+        }
+    }
+    get loading() {
+        return this.loadingSubject.value;
+    }
+    get loaded() {
+        return !this.loadingSubject.value;
+    }
+    enableSort() {
+        if (this.sort)
+            this.sort.disabled = false;
+    }
+    disableSort() {
+        if (this.sort)
+            this.sort.disabled = true;
+    }
+    set pageSize(value) {
+        this.defaultPageSize = value;
+        if (this.paginator) {
+            this.paginator.pageSize = value;
+        }
+    }
+    get pageSize() {
+        return this.paginator && this.paginator.pageSize || this.defaultPageSize || DEFAULT_PAGE_SIZE;
+    }
+    get pageOffset() {
+        return this.paginator && this.paginator.pageIndex * this.paginator.pageSize || 0;
+    }
+    get sortActive() {
+        return this.sort && this.sort.active;
+    }
+    get sortDirection() {
+        return this.sort && this.sort.direction && (this.sort.direction === 'desc' ? 'desc' : 'asc') || undefined;
+    }
+    set paginator(value) {
+        this._paginator = value;
+    }
+    get paginator() {
+        return this._paginator || this.childPaginator;
+    }
+    get destroyed() {
+        var _a;
+        return ((_a = this.destroySubject) === null || _a === void 0 ? void 0 : _a.closed) !== false;
+    }
+    ngOnInit() {
+        var _a;
+        if (this._initialized)
+            return; // Init only once
+        this._initialized = true;
+        // Set defaults
+        this.readOnly = toBoolean(this.readOnly, ((_a = this.dataSource) === null || _a === void 0 ? void 0 : _a.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.errorTranslatorOptions = this.errorTranslatorOptions || { separator: ', ', controlPathTranslator: 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 === null || row === void 0 ? void 0 : row.validator) && true), mergeMap(row => row.validator.valueChanges
+            .pipe(filter(row => row.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((this.autoLoad ? {} : 'skip')), switchMap((event) => {
+            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)));
+        // Listen dataSource loading events
+        if (this._dataSource)
+            this.listenDatasourceLoading(this._dataSource);
+    }
+    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();
+    }
+    updateView(res, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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) {
+                yield this.markAsUntouched({ emitEvent: false });
+                this.markAsPristine({ emitEvent: false });
+                this.markAsLoaded({ emitEvent: false });
+            }
+            this.markForCheck();
+        });
+    }
+    setDatasource(datasource) {
+        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?.close();
+        this._dataSource = null;
+    }
+    addColumnDef(column) {
+        this.table.addColumnDef(column);
+    }
+    removeColumnDef(column) {
+        this.table.removeColumnDef(column);
+    }
+    setFilter(filter, opts) {
+        opts = opts || { emitEvent: true };
+        if (this.saveBeforeFilter) {
+            // if a dirty table is to be saved before filter
+            if (this.dirty) {
+                // Save
+                this.saveBeforeAction('filter').then(saved => {
+                    // Apply filter only if user didn't cancel the save or the save is ok
+                    if (saved) {
+                        this.applyFilter(filter, opts);
+                    }
+                });
+            }
+            else {
+                // apply filter on non-dirty table
+                this.applyFilter(filter, opts);
+            }
+        }
+        else {
+            // apply filter directly
+            this.applyFilter(filter, opts);
+        }
+    }
+    confirmAndAdd(event, row) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.confirmEditCreate(event, row))) {
+                return false;
+            }
+            // Add row
+            return yield this.addRow(event);
+        });
+    }
+    confirmAndBackward(event, row) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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)) {
+                    yield this.deleteNewRow(event, editingRow);
+                }
+                // Wait deletion is done, then edit previous row (by id, because of reloading)
+                yield this.waitIdle();
+                yield this.editRowById(event, row.id, { focusColumn: this.lastUserColumn });
+                return true;
+            }
+            // Edit previous row
+            yield this.editRow(event, row, { focusColumn: this.lastUserColumn });
+            return true;
+        });
+    }
+    confirmAndForward(event, row) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.inlineEdition)
+                return false;
+            yield this.confirmEditCreate(event, row);
+            // Edit next row
+            yield 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
+     */
+    confirmEditCreate(event, row) {
+        return __awaiter(this, void 0, void 0, function* () {
+            row = row || this.dataSource.getSingleEditingRow();
+            if (!row || !row.editing)
+                return true; // no row to confirm
+            // Stop event
+            event === null || event === void 0 ? void 0 : event.stopPropagation();
+            // Confirmation edition or creation
+            const confirmed = yield 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) {
+                // If pending: Wait end of validation
+                // TODO: remove when using async isValid() function
+                if (row.pending) {
+                    yield AppFormUtils.waitWhilePending(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;
+        });
+    }
+    cancelOrDelete(event, row, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Delete new row
+            if (row.id === -1) {
+                yield this.deleteNewRow(event, row);
+            }
+            // Delete existing (but not editing) row
+            else if (!row.editing) {
+                yield this.deleteExistingRow(event, row, opts);
+            }
+            // Cancel existing (and editing) row
+            else {
+                yield this.cancelExistingRow(event, row, opts);
+            }
+        });
+    }
+    addRow(event, insertAt, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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) {
+                yield this.openNewRowDetail(event);
+                return false;
+            }
+            // Try to finish edited row first
+            if (!(yield this.confirmEditCreate())) {
+                return false;
+            }
+            // Add new row
+            const row = yield this.addRowToTable(insertAt, opts);
+            return !!row;
+        });
+    }
+    save(opts) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            opts = Object.assign({ 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 === null || editedRow === void 0 ? void 0 : editedRow.editing) ? editedRow.id : undefined) || ((_a = this.singleSelectedRow) === null || _a === void 0 ? void 0 : _a.id)) : undefined;
+            const previouslyEditedData = opts.keepEditing ? (isNotNil(this.previouslyEditedRowId) && (editedRow === null || editedRow === void 0 ? void 0 : editedRow.currentData) || ((_b = this.singleSelectedRow) === null || _b === void 0 ? void 0 : _b.currentData)) : undefined;
+            if (!(yield 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 = yield 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(this.previouslyEditedRowId)) {
+                    yield this.selectRowByIdOrData(this.previouslyEditedRowId, previouslyEditedData);
+                }
+            }
+        });
+    }
+    cancel(event, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Check confirmation
+            if ((!opts || opts.interactive !== false) && this.dirty && (this.confirmBeforeCancel || this.onBeforeCancelRows.observers.length > 0)) {
+                event === null || event === void 0 ? void 0 : event.stopPropagation();
+                if (!(yield this.canCancelRows())) {
+                    return;
+                }
+            }
+            this.onRefresh.emit();
+        });
+    }
+    duplicateRow(event, row, opts) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            event === null || event === void 0 ? void 0 : event.stopPropagation();
+            row = row || this.singleSelectedRow;
+            if (!row || !(yield this.confirmEditCreate(event, row))) {
+                return false;
+            }
+            const newRow = yield this.addRowToTable(row.id + 1);
+            if (!newRow)
+                throw new Error('Cannot add new row to table');
+            const json = Object.assign(Object.assign({}, row.currentData), { id: null });
+            // Reset some properties (e.g. rankOrder, etc)
+            if (opts && opts.skipProperties) {
+                const newData = newRow.currentData;
+                opts.skipProperties.forEach(key => json[key] = newData[key]);
+            }
+            if (newRow.validator) {
+                newRow.validator.patchValue(json);
+                newRow.validator.markAsDirty();
+            }
+            else {
+                if ((_a = newRow.currentData) === null || _a === void 0 ? void 0 : _a.fromObject) {
+                    newRow.currentData.fromObject(json);
+                }
+                else {
+                    newRow.currentData = json;
+                }
+                this.markAsDirty();
+            }
+            // select
+            yield 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. */
+    masterToggle() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.loading)
+                return;
+            if (this.isAllSelected()) {
+                this.selection.clear();
+            }
+            else {
+                const rows = this._dataSource.getRows();
+                rows.forEach(row => this.selection.select(row));
+            }
+        });
+    }
+    deleteSelection(event, opts) {
+        return this.deleteRows(event, this.selection.selected, opts);
+    }
+    /**
+     *
+     * @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, row, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deleteCount = yield 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
+     */
+    deleteRows(event, rows, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.readOnly) {
+                throw { code: ErrorCodes.TABLE_READ_ONLY, message: 'ERROR.TABLE_READ_ONLY' };
+            }
+            if (event === null || event === void 0 ? void 0 : event.defaultPrevented)
+                return 0; // SKip
+            event === null || event === void 0 ? void 0 : event.preventDefault();
+            if (!this._enabled || 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 === null || editedRow === void 0 ? void 0 : editedRow.id) === -1 && editedRow.editing && !rows.includes(editedRow)) {
+                const confirmed = yield this.confirmEditCreate();
+                if (!confirmed)
+                    return 0; // Cannot delete (e.g. edited row is invalid)
+            }
+            // Check if it can delete
+            const canDelete = yield 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);
+            let deletedRows = [];
+            // 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}`);
+                        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) {
+                        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 = yield 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...`);
+                    yield this._dataSource.deleteAll(tempRows);
+                }
+                // DO not update manually, because watchALl().subscribe() will update this count
+                //this.totalRowCount -= deleteCount;
+                //this.visibleRowCount -= deleteCount;
+                this.selection.clear();
+                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;
+            }
+        });
+    }
+    selectRowById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (id === undefined)
+                return false;
+            yield 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 dataEquals() (that call EntityUtils.equals()) to find same row's data
+     * @param data
+     */
+    selectRowByData(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (data === undefined)
+                return Promise.resolve(false);
+            yield this.waitIdle();
+            const row = this.dataSource.getRows()
+                .find(row => this.equals(row.currentData, data));
+            if (!row)
+                return false;
+            return this.clickRow(null, row);
+        });
+    }
+    clickRow(event, row) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.loading) {
+                // Wait while loading, and loop
+                if (this.debug)
+                    console.debug('[table] Waiting before apply clickRow() (datasource is busy)...');
+                yield this.waitIdle({ timeout: 2000 });
+            }
+            // DEBUG
+            //console.debug("[table] Detect click on row");
+            if (row.id === -1 || row.editing)
+                return true; // Already in edition
+            if (event === null || event === void 0 ? void 0 : event.defaultPrevented)
+                return false; // Cancelled by event
+            // Open the detail page (if not inline editing)
+            if (!this.inlineEdition) {
+                if (event) {
+                    event.stopPropagation();
+                    event.preventDefault();
+                }
+                this.markAsLoading();
+                this.selection.clear();
+                this.openRow(row.currentData.id, row)
+                    .then(() => this.markAsLoaded())
+                    .catch(() => this.markAsLoaded());
+                return true;
+            }
+            // Start editing row
+            return this.editRow(event, row, { focusColumn: undefined /*force to use the click target*/ });
+        });
+    }
+    moveRow(id, direction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.dataSource.move(id, direction);
+        });
+    }
+    ready(opts) {
+        return waitForTrue(this.readySubject, opts);
+    }
+    waitIdle(opts) {
+        return waitForFalse(this.loadingSubject, opts);
+    }
+    openSelectColumnsModal(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            event === null || event === void 0 ? void 0 : event.preventDefault();
+            // Copy current columns (deep copy)
+            const columns = this.getCurrentColumns();
+            const hasTopModal = !!(yield this.modalCtrl.getTop());
+            const modal = yield this.modalCtrl.create({
+                component: TableSelectColumnsComponent,
+                componentProps: { columns },
+                cssClass: hasTopModal && 'stack-modal'
+            });
+            // Open the modal
+            yield modal.present();
+            // On dismiss
+            const { data } = yield 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
+            yield this.settings.savePageSetting(this.settingsId, userColumns, SETTINGS_DISPLAY_COLUMNS);
+        });
+    }
+    trackByFn(index, row) {
+        return row.id;
+    }
+    doRefresh(event) {
+        this.onRefresh.emit(event);
+        // When target wait for a complete (e.g. IonRefresher)
+        if ((event === null || event === void 0 ? void 0 : event.target) && event.target.complete) {
+            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                yield this.waitIdle();
+                event.target.complete();
+            }));
+        }
+    }
+    getCurrentColumns() {
+        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
+        }));
+    }
+    escapeEditingRow(event, row) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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) {
+                        yield AppFormUtils.waitWhilePending(row.validator);
+                    }
+                    // Row is invalid: delete the row
+                    if (row.invalid) {
+                        yield this.deleteNewRow(event, row);
+                        return;
+                    }
+                }
+            }
+            // If the row exists (has an id)
+            else {
+                // need to call cancel function (if confirmation will be called before)
+                if (this.confirmBeforeCancel) {
+                    yield this.cancelExistingRow(event, row, { keepEditing: false });
+                    return;
+                }
+            }
+            // By default, try to confirm the row
+            yield this.confirmEditCreate(event, row);
+        });
+    }
+    translateControlPath(path) {
+        var _a;
+        // Can be overridden by subclasses, to resolve all field name
+        // Use columns key, has default name
+        const i18nColumnKey = this.getI18nColumnName(path);
+        return ((_a = this.translate) === null || _a === void 0 ? void 0 : _a.instant(i18nColumnKey)) || i18nColumnKey;
+    }
+    /* -- protected method -- */
+    editRow(event, row, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._enabled || !this.inlineEdition)
+                return false;
+            if (this.dataSource.getEditingRows().includes(row))
+                return true; // Already the edited row
+            if (event === null || event === void 0 ? void 0 : event.defaultPrevented)
+                return false;
+            if (!(yield this.confirmEditCreate())) {
+                return false;
+            }
+            if (!row.editing && !this.loading) {
+                this.focusColumn = opts && opts.focusColumn || this.focusColumn;
+                yield 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
+     */
+    selectRowByIdOrData(id, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let done = false;
+            try {
+                // Select by row id (if NOT a new row)
+                if (isNotNil(id) || id !== -1) {
+                    done = yield 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 = yield 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
+     */
+    get singleSelectedRow() {
+        var _a;
+        return ((_a = this.selection.selected) === null || _a === void 0 ? void 0 : _a.length) === 1 ? this.selection.selected[0] : undefined;
+    }
+    canDeleteRows(rows, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Check using emitter
+            if (this.onBeforeDeleteRows.observers.length > 0) {
+                try {
+                    const canDelete = yield 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;
+        });
+    }
+    canCancelRows(rows, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get dirty rows
+            rows = rows || this.dataSource.getRows().filter(row => { var _a; return (_a = row.validator) === null || _a === void 0 ? void 0 : _a.dirty; });
+            if (isEmptyArray(rows))
+                return true; // No dirty: OK
+            // Check using emitter
+            if (this.onBeforeCancelRows.observers.length > 0) {
+                try {
+                    const isCancel = yield 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;
+        });
+    }
+    saveBeforeAction(saveAction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.dirty) {
+                // Continue without save
+                return true;
+            }
+            let save;
+            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.observers.length > 0) {
+                    // Ask confirmation
+                    try {
+                        const res = yield 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 = yield 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
+     */
+    openRow(id, row) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.allowRowDetail) {
+                if (this.debug && this.dirty) {
+                    console.warn('[table] Opening row details, but table has unsaved changes!');
+                }
+                if (this.onOpenRow.observers.length) {
+                    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;
+                }
+                return this.router.navigate(['.', id.toString()], {
+                    relativeTo: this.route,
+                    queryParams: {}
+                });
+            }
+            return false;
+        });
+    }
+    openNewRowDetail(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.allowRowDetail)
+                return false;
+            if (this.onNewRow.observers.length > 0) {
+                this.onNewRow.emit(event);
+                return true;
+            }
+            return yield this.router.navigate(['new'], {
+                relativeTo: this.route
+            });
+        });
+    }
+    // can be overridden to add more required columns
+    getRequiredColumns() {
+        return DEFAULT_REQUIRED_COLUMNS;
+    }
+    getUserColumns() {
+        return this.settings.getPageSettings(this.settingsId, SETTINGS_DISPLAY_COLUMNS);
+    }
+    getSortedColumn() {
+        const data = this.settings.getPageSettings(this.settingsId, 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 };
+    }
+    getPageSize() {
+        const pageSize = this.settings.getPageSettings(this.settingsId, SETTINGS_PAGE_SIZE);
+        return pageSize || this.defaultPageSize;
+    }
+    getDisplayColumns() {
+        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
+     */
+    updateColumns() {
+        this.displayedColumns = this.getDisplayColumns();
+        if (!this.loading)
+            this.markForCheck();
+    }
+    registerSubscription(sub) {
+        this._subscription.add(sub);
+    }
+    unregisterSubscription(sub) {
+        this._subscription.remove(sub);
+    }
+    registerAutocompleteField(fieldName, options) {
+        return this._autocompleteConfigHolder.add(fieldName, options);
+    }
+    getI18nColumnName(columnName) {
+        return (this.i18nColumnPrefix || '') + changeCaseToUnderscore(columnName).toUpperCase();
+    }
+    generateTableId() {
+        var _a;
+        // noinspection JSNonASCIINames
+        const id = this.location.path(true)
+            .replace(/[?].*$/g, '')
+            .replace(/\/\d+/g, '_id')
+            + '_'
+            // Get a component unique name - See https://stackoverflow.com/questions/60114682/how-to-access-components-unique-encapsulation-id-in-angular-9
+            + (((_a = this.constructor['ɵcmp']) === null || _a === void 0 ? void 0 : _a.id) || this.constructor.name);
+        //if (this.debug) console.debug("[table] id = " + id);
+        return id;
+    }
+    addRowToTable(insertAt, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Try to finish edited row first
+            if (!(yield 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 = yield this._dataSource.createNew(insertAt, { editing });
+            if (!row)
+                return undefined;
+            if (row.editing) {
+                // Update focused column
+                this.focusFirstColumn = true;
+                this.focusColumn = (opts === null || opts === void 0 ? void 0 : 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;
+        });
+    }
+    registerCellValueChanges(name, formPath, emitInitialValue) {
+        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(),
+                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;
+    }
+    setShowColumn(columnName, show, opts) {
+        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();
+            }
+        }
+    }
+    getShowColumn(columnName) {
+        return !this.excludesColumns.includes(columnName);
+    }
+    startsWithUpperCase(input, search) {
+        return input && input.toUpperCase().startsWith(search);
+    }
+    markForCheck() {
+        // Should be overridden by subclasses, depending on ChangeDetectionStrategy
+    }
+    askDeleteConfirmation(event, rows) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.undoableDeletion) {
+                // Special message, for undoable deletion
+                return Alerts.askConfirmation((rows === null || rows === void 0 ? void 0 : 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);
+        });
+    }
+    askCancelConfirmation(event, rows) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Alerts.askConfirmation((rows === null || rows === void 0 ? void 0 : rows.length) === 1 ? 'CONFIRM.CANCEL_ROW' : 'CONFIRM.CANCEL_ROWS', this.alertCtrl, this.translate, event);
+        });
+    }
+    askRestoreConfirmation(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Alerts.askActionConfirmation(this.alertCtrl, this.translate, false, event);
+        });
+    }
+    showToast(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.toastController)
+                throw new Error('Missing toastController in component\'s constructor');
+            return Toasts.show(this.toastController, this.translate, opts);
+        });
+    }
+    resetError(opts) {
+        this.setError(undefined, opts);
+    }
+    getRowError(row, opts) {
+        row = row || this.dataSource.getSingleEditingRow();
+        if (!row || !this.formErrorAdapter)
+            return undefined;
+        return this.formErrorAdapter.translateFormErrors(row.validator, Object.assign(Object.assign({}, this.errorTranslatorOptions), opts));
+    }
+    setError(value, opts) {
+        if (this.errorSubject.value !== value) {
+            this.errorSubject.next(value);
+            if (!opts || opts.emitEvent !== false) {
+                this.markForCheck();
+            }
+        }
+    }
+    /**
+     * Compare data equality (default by id)
+     * Can be overridden to add additional properties to compare
+     *
+     * @param d1
+     * @param d2
+     * @protected
+     */
+    equals(d1, d2) {
+        return EntityUtils.equals(d1, d2, 'id');
+    }
+    markRowAsDirty(row, opts) {
+        var _a;
+        row = row || this.dataSource.getSingleEditingRow();
+        if (row)
+            (_a = row.validator) === null || _a === void 0 ? void 0 : _a.markAsDirty(opts);
+        this.markAsDirty(opts);
+    }
+    /* -- private method -- */
+    listenSortAndPaginationEvents() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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
+                yield 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(() => __awaiter(this, void 0, void 0, function* () { return this.saveBeforeAction('sort'); })), filter(res => res === true), 
+            // Save sort in settings
+            tap(() => {
+                const value = [this.sort.active, this.sort.direction || 'asc'].join(':');
+                this.settings.savePageSetting(this.settingsId, 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.settings.savePageSetting(this.settingsId, this.paginator.pageSize, SETTINGS_PAGE_SIZE))) || EMPTY)
+                // Refresh on any sort or paginator events
+                .subscribe(value => {
+                this.onSort.emit(value);
+                this.onRefresh.emit(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));
+            }
+        });
+    }
+    editRowById(event, id, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (id < 0)
+                return;
+            if (id >= this.visibleRowCount) {
+                yield this.addRow(event, undefined, Object.assign(Object.assign({}, opts), { editing: true }));
+            }
+            else {
+                const row = yield this.dataSource.getRow(id);
+                yield this.editRow(event, row, opts);
+            }
+        });
+    }
+    setLoading(value, opts) {
+        if (this.loadingSubject.value !== value) {
+            this.loadingSubject.next(value);
+            if (!opts || opts.emitEvent !== false) {
+                this.markForCheck();
+            }
+        }
+    }
+    deleteNewRow(event, row) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (row.id !== -1)
+                throw new Error('Row must have id = -1');
+            event === null || event === void 0 ? void 0 : event.stopPropagation();
+            this.selection.clear();
+            yield this._dataSource.cancelOrDelete(row);
+            this.onCancelOrDeleteRow.next(row);
+            this.resetError();
+            this.totalRowCount--;
+            this.visibleRowCount--;
+        });
+    }
+    deleteExistingRow(event, row, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Make sure row will be cancelled, and NOT deleted
+            if (row.id === -1)
+                throw new Error('Row must have an id');
+            if (event === null || event === void 0 ? void 0 : event.defaultPrevented)
+                return 0; // SKip
+            event === null || event === void 0 ? void 0 : event.preventDefault();
+            yield this.deleteRow(null, row, opts);
+        });
+    }
+    cancelExistingRow(event, row, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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.observers.length > 0)) {
+                event.stopPropagation();
+                if (!(yield this.canCancelRows([row], opts))) {
+                    return;
+                }
+            }
+            const keepEditing = row.editing && (!opts || opts.keepEditing !== false);
+            yield this._dataSource.cancelOrDelete(row);
+            this.onCancelOrDeleteRow.next(row);
+            // Mark row as pristine
+            yield this.checkIfRowPristine(row);
+            // Restore editing state
+            if (keepEditing) {
+                yield this.editRow(undefined, row);
+            }
+        });
+    }
+    checkIfRowPristine(row, opts) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            // Mark row as pristine
+            const markRowAsPristine = ((_a = this.dataSource) === null || _a === void 0 ? void 0 : _a.config.restoreOriginalDataOnCancel) === true;
+            if (markRowAsPristine) {
+                (_b = row.validator) === null || _b === void 0 ? void 0 : _b.markAsPristine();
+                // Check if table is now pristine
+                if (!opts || opts.onlySelf !== true) {
+                    yield this.checkIfPristine(opts);
+                }
+            }
+        });
+    }
+    checkIfPristine(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.dirty)
+                return; // Already pristine
+            const rows = this._dataSource.getRows();
+            const pristine = (rows || []).findIndex(row => row.dirty) === -1;
+            if (pristine)
+                this.markAsPristine(opts);
+        });
+    }
+    applyFilter(filter, opts) {
+        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.onRefresh.emit();
+        }
+    }
+    listenDatasourceLoading(dataSource) {
+        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(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);
+    }
+    startCellValueChanges(name, row) {
+        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);
+            }
+        }
+    }
+    stopCellValueChanges(name, destroy) {
+        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();
+        }
+    }
+}
+AppAsyncTable.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AppAsyncTable, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+AppAsyncTable.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.12", type: AppAsyncTable, inputs: { 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" }, outputs: { 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" }, viewQueries: [{ propertyName: "table", first: true, predicate: MatTable, descendants: true }, { propertyName: "childPaginator", first: true, predicate: MatPaginator, descendants: true }, { propertyName: "sort", first: true, predicate: MatSort, descendants: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AppAsyncTable, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: undefined }, { type: EntitiesAsyncTableDataSource }, { type: undefined }]; }, propDecorators: { settingsId: [{
+                type: Input
+            }], debug: [{
+                type: Input
+            }], i18nColumnPrefix: [{
+                type: Input
+            }], i18nColumnSuffix: [{
+                type: Input
+            }], autoLoad: [{
+                type: Input
+            }], readOnly: [{
+                type: Input
+            }], inlineEdition: [{
+                type: Input
+            }], focusFirstColumn: [{
+                type: Input
+            }], confirmBeforeDelete: [{
+                type: Input
+            }], confirmBeforeCancel: [{
+                type: Input
+            }], undoableDeletion: [{
+                type: Input
+            }], saveBeforeDelete: [{
+                type: Input
+            }], keepEditedRowOnSave: [{
+                type: Input
+            }], saveBeforeSort: [{
+                type: Input
+            }], saveBeforeFilter: [{
+                type: Input
+            }], propagateRowError: [{
+                type: Input
+            }], defaultSortBy: [{
+                type: Input
+            }], defaultSortDirection: [{
+                type: Input
+            }], defaultPageSize: [{
+                type: Input
+            }], defaultPageSizeOptions: [{
+                type: Input
+            }], focusColumn: [{
+                type: Input
+            }], dataSource: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], onRefresh: [{
+                type: Output
+            }], onOpenRow: [{
+                type: Output
+            }], onNewRow: [{
+                type: Output
+            }], onStartEditingRow: [{
+                type: Output
+            }], onConfirmEditCreateRow: [{
+                type: Output
+            }], onCancelOrDeleteRow: [{
+                type: Output
+            }], onBeforeDeleteRows: [{
+                type: Output
+            }], onBeforeCancelRows: [{
+                type: Output
+            }], onBeforeSave: [{
+                type: Output
+            }], onAfterDeletedRows: [{
+                type: Output
+            }], onSort: [{
+                type: Output
+            }], onDirty: [{
+                type: Output
+            }], onError: [{
+                type: Output
+            }], disabled: [{
+                type: Input
+            }], paginator: [{
+                type: Input
+            }], table: [{
+                type: ViewChild,
+                args: [MatTable, { static: false }]
+            }], childPaginator: [{
+                type: ViewChild,
+                args: [MatPaginator, { static: false }]
+            }], sort: [{
+                type: ViewChild,
+                args: [MatSort, { static: false }]
+            }] } });
+
 // @dynamic
 // eslint-disable-next-line @angular-eslint/directive-class-suffix
 class AppInMemoryTable extends AppTable {
@@ -34097,5 +36175,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { APP_ABOUT_DEVELOPERS, APP_ABOUT_PARTNERS, APP_CONFIG_OPTIONS, APP_FORM_ERROR_I18N_KEYS, APP_GRAPHQL_TYPE_POLICIES, APP_HOME_BUTTONS, APP_JOB_PROGRESSION_SERVICE, APP_LOCALES, APP_LOCAL_SETTINGS, APP_LOCAL_SETTINGS_OPTIONS, APP_LOCAL_STORAGE_TYPE_POLICIES, APP_MENU_ITEMS, APP_MENU_OPTIONS, APP_STORAGE, APP_TESTING_PAGES, APP_USER_EVENT_SERVICE, AboutModal, AbstractDateFormat, AbstractUserEventService, Account, AccountPage, AccountService, AccountToStringPipe, ActionsColumnComponent, AdminModule, AdminRoutingModule, AdminUsersModule, Alerts, AndroidOsEnvironment, AnimationState, AppAboutModalModule, AppAccountModule, AppAuthForm, AppAuthModal, AppAuthModule, AppEditor, AppEditorOptions, AppEntityEditor, AppEntityEditorModal, AppEntityEditorModalOptions, AppEntityFormModule, AppForm, AppFormArray, AppFormButtonsBarModule, AppFormField, AppFormModule, AppFormProvider, AppFormUtils, AppGestureConfig, AppGraphQLModule, AppHelpModal, AppHomePageModule, AppIconComponent, AppIconModule, AppImageGalleryComponent, AppInMemoryTable, AppInstallUpgradeCard, AppInstallUpgradeCardModule, AppListForm, AppListFormModule, AppLoadingSpinner, AppMenuModule, AppNullForm, AppPropertiesForm, AppPropertiesFormModule, AppRegisterModule, AppSelectPeerModule, AppSettingsPageModule, AppTabEditor, AppTabEditorOptions, AppTable, AppTableModule, AppTableUtils, AppTextPopoverModule, AppUpdateOfflineModeCard, AppUpdateOfflineModeCardModule, AppValidatorService, AppendToInputDirective, ArrayFilterPipe, ArrayFirstPipe, ArrayIncludesPipe, ArrayJoinPipe, ArrayLengthPipe, ArrayPluckPipe, AudioProvider, AudioTestingModule, AudioTestingPage, AuthGuardService, AutoTitleDirective, AutocompleteTestPage, AutofocusDirective, BadgeDirective, Base58, BaseEntityService, BaseGraphqlService, BaseGraphqlServiceOptions, BaseReferential, Beans, CORE_CONFIG_OPTIONS, CORE_TESTING_PAGES, CellValueChangeListener, ChipsTestPage, Color, ColorScale, ComponentDirtyGuard, ConfigService, Configuration, CoreModule, CoreTestingModule, CryptoService, CsvUtils, DATE_ISO_PATTERN, DATE_PATTERN, DATE_UNIX_MS_TIMESTAMP, DATE_UNIX_TIMESTAMP, DEFAULT_MENU_SHOW_WHEN, DEFAULT_PAGE_SIZE, DEFAULT_PAGE_SIZE_OPTIONS, DEFAULT_PLACEHOLDER_CHAR, DEFAULT_REQUIRED_COLUMNS, DateDiffDurationPipe, DateFormatPipe, DateFormatService, DateFromNowPipe, DateTestPage, DateTimeTestPage, DateUtils, DebugComponent, Department, DepartmentToStringPipe, DragAndDropDirective, DurationPipe, ED25519_SEED_LENGTH, EMPTY_PLACEHOLDER_CHAR, ENTITIES_STORAGE_KEY_PREFIX, ENVIRONMENT, EmptyArrayPipe, EntitiesStorage, EntitiesTableDataSource, Entity, EntityClass, EntityClasses, EntityFilter, EntityFilterUtils, EntityMetadataComponent, EntityStore, EntityUtils, Environment, ErrorCodes, EvenPipe, FileResponse, FileService, FileSizePipe, FilesUtils, FormArrayHelper, FormButtonsBarComponent, FormButtonsBarToken, FormErrorTranslatePipe, FormErrorTranslator, FormFieldValuesHolder, FormGetArrayPipe, FormGetControlPipe, FormGetGroupPipe, FormGetPipe, FormGetValuePipe, Fragments, GalleryTestPage, GeolocationUtils, GraphqlService, HAMMER_PRESS_TIME, HAMMER_TAP_TIME, HighlightPipe, HomePage, Hotkeys, HotkeysDialogComponent, IMAGE_DEFAULTS, IPosition, ImageAttachment, ImageAttachmentFilter, ImageAttachmentService, ImageGalleryModule, ImageGalleryTestingModule, ImageModule, ImageService, ImagesUtils, InMemoryEntitiesService, IsLoginAccountPipe, IsNilOrBlankPipe, IsNotNilOrBlankPipe, IsNotNilOrNaNPipe, IsNotNilPipe, IsNotOnFieldModePipe, IsOnFieldModePipe, JobModule, JobProgression, JobProgressionIcon, JobProgressionList, JobProgressionService, JobProgressionTestService, JobProgressionTestingPage, JobTestingModule, JobUtils, JsonUtils, KEYBOARD_HIDE_DELAY_MS, LAT_LONG_DEFAULT_MAX_DECIMALS, LAT_LONG_PATTERNS, LatLongFormatPipe, LatLongTestPage, LatitudeFormatPipe, LocalSettingsService, LongitudeFormatPipe, MINIFY_ENTITY_FOR_LOCAL_STORAGE, MINIFY_ENTITY_FOR_POD, MOMENT_NO_TIME_PROPERTY, MapGetPipe, MapKeysPipe, MapValuesPipe, MatAutocompleteConfigHolder, MatAutocompleteField, MatAutocompleteFieldUtils, MatBooleanField, MatChipsField, MatColorPipe, MatDate, MatDateShort, MatDateTime, MatDuration, MatLatLongField, MatNumpadComponent, MatNumpadContainerComponent, MatNumpadContent, MatPaginatorI18n, MatStepperI18n, MatSwipeField, MaterialTestingModule, MathAbsPipe, MenuComponent, MenuItems, MenuOptions, MenuService, Message, MessageFilter, MessageForm, MessageModal, MessageModule, MessageService, MessageTypeList, MessageTypes, MimeTypes, ModalToolbarComponent, NetworkService, NgInitDirective, NgVarDirective, NotEmptyArrayPipe, NumberFormatPipe, NumpadDirective, NumpadTestPage, ObservableTestPage, OddPipe, PEER_URL_REGEXP, PRIORITIZED_AUTHORITIES, PUBKEY_REGEXP, Peer, Person, PersonFilter, PersonFragments, PersonService, PersonToStringPipe, PersonUtils, PersonValidatorService, PlatformService, ProgressBarService, ProgressInterceptor, PropertiesFormTestPage, PropertiesFormTestingModule, PropertyFormatPipe, PropertyGetPipe, RESERVED_END_COLUMNS, RESERVED_START_COLUMNS, Referential, ReferentialFilter, ReferentialRef, ReferentialUtils, ReferentialValidatorService, RegisterConfirmPage, RegisterForm, RegisterModal, ResizableComponent, ResizableDirective, ResizableModule, SCRYPT_PARAMS, SETTINGS_DISPLAY_COLUMNS, SETTINGS_FILTER, SETTINGS_PAGE_SIZE, SETTINGS_SORTED_COLUMN, SETTINGS_STORAGE_KEY, SETTINGS_TRANSIENT_PROPERTIES, SHARED_MATERIAL_TESTING_PAGES, SHARED_TESTING_PAGES, SOCIAL_TESTING_PAGES, SPACE_PLACEHOLDER_CHAR, SelectPeerModal, ServerErrorCodes, SettingsPage, SharedAsyncValidators, SharedBadgeModule, SharedDebugModule, SharedDirectivesModule, SharedFormArrayValidators, SharedFormGroupValidators, SharedHotkeysModule, SharedMatAutocompleteModule, SharedMatBooleanModule, SharedMatChipsModule, SharedMatDateTimeModule, SharedMatDurationModule, SharedMatLatLongModule, SharedMatNumpadModule, SharedMatSwipeModule, SharedMaterialModule, SharedModule, SharedPipesModule, SharedRoutingModule, SharedTestingModule, SharedTestsPage, SharedToolbarModule, SharedValidators, SocialErrorCodes, SocialModule, SocialModuleOptionsToken, SocialTestingModule, Software, StartableService, StatusById, StatusIds, StatusList, StorageDrivers, StorageService, StrIncludesPipe, StrLengthPipe, SwipeTestPage, TableSelectColumnsComponent, TableTestPage, TableTestingModule, TextForm, TextPopover, TextPopoverTestingModule, TextPopoverTestingPage, ToStringPipe, ToastTestingModule, ToastTestingPage, Toasts, ToolbarComponent, ToolbarToken, TranslatablePipe, TranslateContextPipe, TranslateContextService, UploadFile, UploadFileComponent, UploadFilePopover, UploadFileTestingModule, UploadFileTestingPage, UriUtils, UserEventModule, UserEventNotificationIcon, UserEventTestService, UserEventTestingModule, UserEventTestingPage, UserSettings, UsersPage, accountToString, adaptValueToControl, addValueInArray, arrayDistinct, arrayGroupBy, arraySize, asInputElement, canHaveFocus, capitalizeFirstLetter, chainPromises, changeCaseToUnderscore, clearValueInArray, copyEntity2Form, createPromiseEvent, createPromiseEventEmitter, departmentToString, departmentsToString, disableControls, emitPromiseEvent, entityToString, equals, equalsOrNil, escapeRegExp, fadeInAnimation, fadeInOutAnimation, filterFalse, filterNotNil, filterNumberInput, filterTrue, firstArrayValue, firstFalse, firstFalsePromise, firstNotNil, firstNotNilPromise, firstTrue, firstTruePromise, focusInput, focusNextInput, focusPreviousInput, formatLatitude, formatLongitude, fromDateISOString, fromScrollEndEvent, fromUnixMsTimestamp, fromUnixTimestamp, getCaretPosition, getColorContrast, getColorShade, getColorTint, getConnectionType, getControlFromPath, getFocusableInputElements, getFormErrors, getFormValueFromEntity, getProperty, getPropertyByPath, getPropertyByPathAsString, getRandomImage, hexToRgb, hexToRgbArray, initArrayControlsFromValues, isAndroid, isBlankString, isCapacitor, isControlHasInput, isCordova, isEmptyArray, isIOS, isInputElement, isInstanceOf, isInt, isMobile, isNil, isNilOrBlank, isNilOrNaN, isNotEmptyArray, isNotNil, isNotNilBoolean, isNotNilOrBlank, isNotNilOrNaN, isNotNilString, isNumber, isNumberRange, isProgressEvent, isResponseEvent, isTouchUi, isWindows, joinProperties, joinPropertiesPath, logFormErrors, markAllAsTouched, markAsUntouched, markControlAsTouched, markFormGroupAsTouched, matchMedia, matchUpperCase, mergeLoadResult, mixHex, moveInputCaretToSeparator, noTrailingSlash, notNilOrDefault, nullIfUndefined, parseLatitudeOrLongitude, propertiesPathComparator, propertyComparator, propertyPathComparator, referentialToString, referentialsToString, remove, removeAll, removeDiacritics, removeDuplicatesFromArray, removeEnd, removeValueInArray, replaceAll, resetCalculatedValue, resizeArray, rgbArrayToHex, rgbToHex, round, scrollFactory, selectInputContent, selectInputRange, setCalculatedValue, setTabIndex, sleep, slideInOutAnimation, slideUpDownAnimation, sort, splitById, splitByProperty, startsWithUpperCase, suggestFromArray, suggestFromStringArray, tabindexComparator, testUserAgent, toBoolean, toDateISOString, toDuration, toFloat, toInt, toNotNil, toNumber, trimEmptyToNull, uncapitalizeFirstLetter, updateValueAndValidity, waitFor, waitForFalse, waitForTrue, waitIdle, waitWhilePending };
+export { APP_ABOUT_DEVELOPERS, APP_ABOUT_PARTNERS, APP_CONFIG_OPTIONS, APP_FORM_ERROR_I18N_KEYS, APP_GRAPHQL_TYPE_POLICIES, APP_HOME_BUTTONS, APP_JOB_PROGRESSION_SERVICE, APP_LOCALES, APP_LOCAL_SETTINGS, APP_LOCAL_SETTINGS_OPTIONS, APP_LOCAL_STORAGE_TYPE_POLICIES, APP_MENU_ITEMS, APP_MENU_OPTIONS, APP_STORAGE, APP_TESTING_PAGES, APP_USER_EVENT_SERVICE, AboutModal, AbstractDateFormat, AbstractUserEventService, Account, AccountPage, AccountService, AccountToStringPipe, ActionsColumnComponent, AdminModule, AdminRoutingModule, AdminUsersModule, Alerts, AndroidOsEnvironment, AnimationState, AppAboutModalModule, AppAccountModule, AppAsyncTable, AppAuthForm, AppAuthModal, AppAuthModule, AppEditor, AppEditorOptions, AppEntityEditor, AppEntityEditorModal, AppEntityEditorModalOptions, AppEntityFormModule, AppForm, AppFormArray, AppFormButtonsBarModule, AppFormField, AppFormModule, AppFormProvider, AppFormUtils, AppGestureConfig, AppGraphQLModule, AppHelpModal, AppHomePageModule, AppIconComponent, AppIconModule, AppImageGalleryComponent, AppInMemoryTable, AppInstallUpgradeCard, AppInstallUpgradeCardModule, AppListForm, AppListFormModule, AppLoadingSpinner, AppMenuModule, AppNullForm, AppPropertiesForm, AppPropertiesFormModule, AppRegisterModule, AppSelectPeerModule, AppSettingsPageModule, AppTabEditor, AppTabEditorOptions, AppTable, AppTableModule, AppTableUtils, AppTextPopoverModule, AppUpdateOfflineModeCard, AppUpdateOfflineModeCardModule, AppValidatorService, AppendToInputDirective, ArrayFilterPipe, ArrayFirstPipe, ArrayIncludesPipe, ArrayJoinPipe, ArrayLengthPipe, ArrayPluckPipe, AudioProvider, AudioTestingModule, AudioTestingPage, AuthGuardService, AutoTitleDirective, AutocompleteTestPage, AutofocusDirective, BadgeDirective, Base58, BaseEntityService, BaseGraphqlService, BaseGraphqlServiceOptions, BaseReferential, Beans, CORE_CONFIG_OPTIONS, CORE_TESTING_PAGES, CellValueChangeListener, ChipsTestPage, Color, ColorScale, ComponentDirtyGuard, ConfigService, Configuration, CoreModule, CoreTestingModule, CryptoService, CsvUtils, DATE_ISO_PATTERN, DATE_PATTERN, DATE_UNIX_MS_TIMESTAMP, DATE_UNIX_TIMESTAMP, DEFAULT_MENU_SHOW_WHEN, DEFAULT_PAGE_SIZE, DEFAULT_PAGE_SIZE_OPTIONS, DEFAULT_PLACEHOLDER_CHAR, DEFAULT_REQUIRED_COLUMNS, DateDiffDurationPipe, DateFormatPipe, DateFormatService, DateFromNowPipe, DateTestPage, DateTimeTestPage, DateUtils, DebugComponent, Department, DepartmentToStringPipe, DragAndDropDirective, DurationPipe, ED25519_SEED_LENGTH, EMPTY_PLACEHOLDER_CHAR, ENTITIES_STORAGE_KEY_PREFIX, ENVIRONMENT, EmptyArrayPipe, EntitiesAsyncTableDataSource, EntitiesStorage, EntitiesTableDataSource, Entity, EntityClass, EntityClasses, EntityFilter, EntityFilterUtils, EntityMetadataComponent, EntityStore, EntityUtils, Environment, ErrorCodes, EvenPipe, FileResponse, FileService, FileSizePipe, FilesUtils, FormArrayHelper, FormButtonsBarComponent, FormButtonsBarToken, FormErrorTranslatePipe, FormErrorTranslator, FormFieldValuesHolder, FormGetArrayPipe, FormGetControlPipe, FormGetGroupPipe, FormGetPipe, FormGetValuePipe, Fragments, GalleryTestPage, GeolocationUtils, GraphqlService, HAMMER_PRESS_TIME, HAMMER_TAP_TIME, HighlightPipe, HomePage, Hotkeys, HotkeysDialogComponent, IMAGE_DEFAULTS, IPosition, ImageAttachment, ImageAttachmentFilter, ImageAttachmentService, ImageGalleryModule, ImageGalleryTestingModule, ImageModule, ImageService, ImagesUtils, InMemoryEntitiesService, IsLoginAccountPipe, IsNilOrBlankPipe, IsNotNilOrBlankPipe, IsNotNilOrNaNPipe, IsNotNilPipe, IsNotOnFieldModePipe, IsOnFieldModePipe, JobModule, JobProgression, JobProgressionIcon, JobProgressionList, JobProgressionService, JobProgressionTestService, JobProgressionTestingPage, JobTestingModule, JobUtils, JsonUtils, KEYBOARD_HIDE_DELAY_MS, LAT_LONG_DEFAULT_MAX_DECIMALS, LAT_LONG_PATTERNS, LatLongFormatPipe, LatLongTestPage, LatitudeFormatPipe, LocalSettingsService, LongitudeFormatPipe, MINIFY_ENTITY_FOR_LOCAL_STORAGE, MINIFY_ENTITY_FOR_POD, MOMENT_NO_TIME_PROPERTY, MapGetPipe, MapKeysPipe, MapValuesPipe, MatAutocompleteConfigHolder, MatAutocompleteField, MatAutocompleteFieldUtils, MatBooleanField, MatChipsField, MatColorPipe, MatDate, MatDateShort, MatDateTime, MatDuration, MatLatLongField, MatNumpadComponent, MatNumpadContainerComponent, MatNumpadContent, MatPaginatorI18n, MatStepperI18n, MatSwipeField, MaterialTestingModule, MathAbsPipe, MenuComponent, MenuItems, MenuOptions, MenuService, Message, MessageFilter, MessageForm, MessageModal, MessageModule, MessageService, MessageTypeList, MessageTypes, MimeTypes, ModalToolbarComponent, NetworkService, NgInitDirective, NgVarDirective, NotEmptyArrayPipe, NumberFormatPipe, NumpadDirective, NumpadTestPage, ObservableTestPage, OddPipe, PEER_URL_REGEXP, PRIORITIZED_AUTHORITIES, PUBKEY_REGEXP, Peer, Person, PersonFilter, PersonFragments, PersonService, PersonToStringPipe, PersonUtils, PersonValidatorService, PlatformService, ProgressBarService, ProgressInterceptor, PropertiesFormTestPage, PropertiesFormTestingModule, PropertyFormatPipe, PropertyGetPipe, RESERVED_END_COLUMNS, RESERVED_START_COLUMNS, Referential, ReferentialFilter, ReferentialRef, ReferentialUtils, ReferentialValidatorService, RegisterConfirmPage, RegisterForm, RegisterModal, ResizableComponent, ResizableDirective, ResizableModule, SCRYPT_PARAMS, SETTINGS_DISPLAY_COLUMNS, SETTINGS_FILTER, SETTINGS_PAGE_SIZE, SETTINGS_SORTED_COLUMN, SETTINGS_STORAGE_KEY, SETTINGS_TRANSIENT_PROPERTIES, SHARED_MATERIAL_TESTING_PAGES, SHARED_TESTING_PAGES, SOCIAL_TESTING_PAGES, SPACE_PLACEHOLDER_CHAR, SelectPeerModal, ServerErrorCodes, SettingsPage, SharedAsyncValidators, SharedBadgeModule, SharedDebugModule, SharedDirectivesModule, SharedFormArrayValidators, SharedFormGroupValidators, SharedHotkeysModule, SharedMatAutocompleteModule, SharedMatBooleanModule, SharedMatChipsModule, SharedMatDateTimeModule, SharedMatDurationModule, SharedMatLatLongModule, SharedMatNumpadModule, SharedMatSwipeModule, SharedMaterialModule, SharedModule, SharedPipesModule, SharedRoutingModule, SharedTestingModule, SharedTestsPage, SharedToolbarModule, SharedValidators, SocialErrorCodes, SocialModule, SocialModuleOptionsToken, SocialTestingModule, Software, StartableService, StatusById, StatusIds, StatusList, StorageDrivers, StorageService, StrIncludesPipe, StrLengthPipe, SwipeTestPage, TableSelectColumnsComponent, TableTestPage, TableTestingModule, TextForm, TextPopover, TextPopoverTestingModule, TextPopoverTestingPage, ToStringPipe, ToastTestingModule, ToastTestingPage, Toasts, ToolbarComponent, ToolbarToken, TranslatablePipe, TranslateContextPipe, TranslateContextService, UploadFile, UploadFileComponent, UploadFilePopover, UploadFileTestingModule, UploadFileTestingPage, UriUtils, UserEventModule, UserEventNotificationIcon, UserEventTestService, UserEventTestingModule, UserEventTestingPage, UserSettings, UsersPage, accountToString, adaptValueToControl, addValueInArray, arrayDistinct, arrayGroupBy, arraySize, asInputElement, canHaveFocus, capitalizeFirstLetter, chainPromises, changeCaseToUnderscore, clearValueInArray, copyEntity2Form, createPromiseEvent, createPromiseEventEmitter, departmentToString, departmentsToString, disableControls, emitPromiseEvent, entityToString, equals, equalsOrNil, escapeRegExp, fadeInAnimation, fadeInOutAnimation, filterFalse, filterNotNil, filterNumberInput, filterTrue, firstArrayValue, firstFalse, firstFalsePromise, firstNotNil, firstNotNilPromise, firstTrue, firstTruePromise, focusInput, focusNextInput, focusPreviousInput, formatLatitude, formatLongitude, fromDateISOString, fromScrollEndEvent, fromUnixMsTimestamp, fromUnixTimestamp, getCaretPosition, getColorContrast, getColorShade, getColorTint, getConnectionType, getControlFromPath, getFocusableInputElements, getFormErrors, getFormValueFromEntity, getProperty, getPropertyByPath, getPropertyByPathAsString, getRandomImage, hexToRgb, hexToRgbArray, initArrayControlsFromValues, isAndroid, isBlankString, isCapacitor, isControlHasInput, isCordova, isEmptyArray, isIOS, isInputElement, isInstanceOf, isInt, isMobile, isNil, isNilOrBlank, isNilOrNaN, isNotEmptyArray, isNotNil, isNotNilBoolean, isNotNilOrBlank, isNotNilOrNaN, isNotNilString, isNumber, isNumberRange, isProgressEvent, isResponseEvent, isTouchUi, isWindows, joinProperties, joinPropertiesPath, logFormErrors, markAllAsTouched, markAsUntouched, markControlAsTouched, markFormGroupAsTouched, matchMedia, matchUpperCase, mergeLoadResult, mixHex, moveInputCaretToSeparator, noTrailingSlash, notNilOrDefault, nullIfUndefined, parseLatitudeOrLongitude, propertiesPathComparator, propertyComparator, propertyPathComparator, referentialToString, referentialsToString, remove, removeAll, removeDiacritics, removeDuplicatesFromArray, removeEnd, removeValueInArray, replaceAll, resetCalculatedValue, resizeArray, rgbArrayToHex, rgbToHex, round, scrollFactory, selectInputContent, selectInputRange, setCalculatedValue, setTabIndex, sleep, slideInOutAnimation, slideUpDownAnimation, sort, splitById, splitByProperty, startsWithUpperCase, suggestFromArray, suggestFromStringArray, tabindexComparator, testUserAgent, toBoolean, toDateISOString, toDuration, toFloat, toInt, toNotNil, toNumber, trimEmptyToNull, uncapitalizeFirstLetter, updateValueAndValidity, waitFor, waitForFalse, waitForTrue, waitIdle, waitWhilePending };
 //# sourceMappingURL=sumaris-net.ngx-components.mjs.map