@tetacom/ng-components 1.0.24 → 1.0.25

package/dist/esm2020/component/table/selection-head-cell/selection-head-cell.component.mjs

@@ -0,0 +1,45 @@
+import { ChangeDetectionStrategy, Component, HostBinding, } from '@angular/core';
+import { takeWhile } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../service/table.service";
+import * as i2 from "../../checkbox/checkbox/checkbox.component";
+import * as i3 from "@angular/forms";
+export class SelectionHeadCellComponent {
+    constructor(_svc, _cdr) {
+        this._svc = _svc;
+        this._cdr = _cdr;
+        this.tableCellClass = true;
+        this._alive = true;
+    }
+    selectAll(value) {
+        if (value) {
+            this._svc.selectAll();
+        }
+        else {
+            this._svc.deselectAll();
+        }
+    }
+    allSelected() {
+        return this._svc.allRowsSelected();
+    }
+    ngOnInit() {
+        this._svc.selectedRows
+            .pipe(takeWhile((_) => this._alive))
+            .subscribe((_) => {
+            this._cdr.markForCheck();
+        });
+    }
+    ngOnDestroy() {
+        this._alive = false;
+    }
+}
+SelectionHeadCellComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: SelectionHeadCellComponent, deps: [{ token: i1.TableService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+SelectionHeadCellComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.1", type: SelectionHeadCellComponent, selector: "teta-selection-head-cell", host: { properties: { "class.table-head__group": "this.tableCellClass" } }, ngImport: i0, template: "<teta-checkbox [binary]=\"true\"\n               [allowNull]=\"true\"\n               [noLabel]=\"true\"\n               [ngModel]=\"allSelected()\"\n               (ngModelChange)=\"selectAll($event)\"></teta-checkbox>\n", styles: [":host{display:flex;align-items:center;justify-content:center}\n"], components: [{ type: i2.CheckboxComponent, selector: "teta-checkbox", inputs: ["class", "palette", "noLabel", "disabled", "value", "binary", "allowNull"] }], directives: [{ type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: SelectionHeadCellComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'teta-selection-head-cell', changeDetection: ChangeDetectionStrategy.OnPush, template: "<teta-checkbox [binary]=\"true\"\n               [allowNull]=\"true\"\n               [noLabel]=\"true\"\n               [ngModel]=\"allSelected()\"\n               (ngModelChange)=\"selectAll($event)\"></teta-checkbox>\n", styles: [":host{display:flex;align-items:center;justify-content:center}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.TableService }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { tableCellClass: [{
+                type: HostBinding,
+                args: ['class.table-head__group']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/component/table/service/table.service.mjs

@@ -0,0 +1,434 @@
+import { Injectable } from '@angular/core';
+import { TableRow } from '../contract/table-row';
+import { TableColumn } from '../contract/table-column';
+import { FilterState } from '../../filter/contarct/filter-state';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { ColumnReorderEvent } from '../contract/column-reorder-event';
+import { ArrayUtil } from '../../../common/util/array-util';
+import { StateUtil } from '../util/state-util';
+import { SelectType } from '../enum/select-type.enum';
+import { ListFilterType } from '../../filter/enum/list-filter-type.enum';
+import { ListFilter } from '../../filter/contarct/list-filter';
+import { FilterType } from '../../filter/enum/filter-type.enum';
+import { NumericFilterValue } from '../../filter/contarct/numeric-filter-value';
+import { NumericFilter } from '../../filter/contarct/numeric-filter';
+import { StringFilter } from '../../filter/contarct/string-filter';
+import { DateFilterValue } from '../../filter/contarct/date-filter-value';
+import { DateFilter } from '../../filter/contarct/date-filter';
+import { DateUtil } from '../../../util/date-util';
+import objectHash from 'object-hash';
+import { TableColumnStore } from '../contract/table-column-store';
+import * as i0 from "@angular/core";
+export class TableService {
+    constructor() {
+        this.initialColumns = [];
+        this.displayColumns = [];
+        this._columns = new BehaviorSubject([]);
+        this.initialData = [];
+        this._displayData = new BehaviorSubject([]);
+        this._dict = new BehaviorSubject({});
+        this._state = new BehaviorSubject(new FilterState());
+        this._editRowStart = new Subject();
+        this._editRowStop = new Subject();
+        this._editCellStart = new Subject();
+        this._editCellStop = new Subject();
+        this._valueChanged = new Subject();
+        this._valueSet = new Subject();
+        this._stateChanged = new Subject();
+        this._filterClear = new Subject();
+        this._groupToggle = new Subject();
+        this._selectedRows = new BehaviorSubject([]);
+        this._activeRow = new BehaviorSubject(null);
+        this._hiddenColumns = new BehaviorSubject([]);
+        this._scrollIndex = new Subject();
+        this.columns = this._columns.asObservable();
+        this.displayData = this._displayData.asObservable();
+        this.dict = this._dict.asObservable();
+        this.state = this._state.asObservable();
+        this.editRowStart = this._editRowStart.asObservable();
+        this.editRowStop = this._editRowStop.asObservable();
+        this.editCellStart = this._editCellStart.asObservable();
+        this.editCellStop = this._editCellStop.asObservable();
+        this.valueChanged = this._valueChanged.asObservable();
+        this.valueSet = this._valueSet.asObservable();
+        this.stateChanged = this._stateChanged.asObservable();
+        this.filterClear = this._filterClear.asObservable();
+        this.groupToggle = this._groupToggle.asObservable();
+        this.selectedRows = this._selectedRows.asObservable();
+        this.activeRow = this._activeRow.asObservable();
+        this.hiddenColumns = this._hiddenColumns.asObservable();
+        this.scrollIndex = this._scrollIndex.asObservable();
+    }
+    // cellEditable: boolean | ((row: ICellCoordinates<T>) => boolean);
+    get dragSource() {
+        return this._dragSource;
+    }
+    setData(data) {
+        this.initialData = data?.map((_) => new TableRow(_));
+        this._displayData.next(this.initialData);
+    }
+    setDict(dict) {
+        this._dict.next(dict);
+    }
+    setColumns(columns) {
+        this.initialColumns = columns ? columns.map((_) => new TableColumn(_)) : [];
+        this.initialColumnsHash = objectHash(this.initialColumns, {
+            algorithm: 'sha1',
+            ignoreUnknown: true,
+            excludeKeys: key => key === 'headDropdownTemplate',
+        });
+        const restored = this.restoreColumns();
+        if (restored) {
+            this.setDisplayColumns(restored);
+        }
+        else {
+            this.setDisplayColumns(this.initialColumns);
+        }
+    }
+    restoreDefaultColumns() {
+        this.setDisplayColumns(this.initialColumns);
+        this.clearColumnsState();
+    }
+    updateColumns(columns) {
+        this.setDisplayColumns(columns);
+        this.saveColumnsState();
+    }
+    saveColumnsState() {
+        if (this._cookieName) {
+            localStorage.setItem(this._columnsCookieName, JSON.stringify({
+                hash: this.initialColumnsHash,
+                columns: this.displayColumns.map((_) => new TableColumnStore(_)),
+            }));
+        }
+    }
+    clearColumnsState() {
+        localStorage.removeItem(this._columnsCookieName);
+    }
+    setDisplayColumns(columns) {
+        this.displayColumns = columns ? columns.map((_) => new TableColumn(_)) : [];
+        this._columns.next(this.displayColumns);
+    }
+    restoreColumns() {
+        const savedColumns = JSON.parse(localStorage.getItem(this._columnsCookieName));
+        if (savedColumns && savedColumns.hash === this.initialColumnsHash) {
+            return this.restoreColumnsState(savedColumns.columns);
+        }
+        return null;
+    }
+    restoreColumnsState(columns) {
+        return columns.map((column) => {
+            const found = ArrayUtil.findRecursive(this.initialColumns, (item) => item.name === column.name, 'columns');
+            const resultColumn = new TableColumn(found);
+            resultColumn.width = column.width;
+            resultColumn.flex = column.flex;
+            resultColumn.locked = column.locked;
+            if (column.columns?.length > 0) {
+                resultColumn.columns = this.restoreColumnsState(column.columns);
+            }
+            return resultColumn;
+        });
+    }
+    setState(state) {
+        state.save(this._cookieName);
+        this._state.next(state);
+    }
+    setCookieName(name) {
+        this._cookieName = name;
+        this._hiddenCookieName = `${this._cookieName}_hidden_columns`;
+        this._columnsCookieName = `${this._cookieName}_columns`;
+    }
+    restoreState() {
+        let state;
+        if (this._cookieName?.length > 0 && FilterState.restore(this._cookieName)) {
+            let newState = Object.assign(this._state.value, FilterState.restore(this._cookieName));
+            newState = DateUtil.convertDateStringsToDates(newState);
+            state = new FilterState(newState);
+        }
+        else {
+            state = new FilterState();
+        }
+        this.setState(state);
+    }
+    saveHiddenColumns(hiddenColumns) {
+        localStorage.setItem(this._hiddenCookieName, JSON.stringify(hiddenColumns));
+    }
+    restoreHiddenColumns() {
+        const hiddenColumns = localStorage.getItem(this._hiddenCookieName) || '[]';
+        this._hiddenColumns.next(JSON.parse(hiddenColumns));
+    }
+    sort(sortEvent) {
+        if (sortEvent.column.sortable) {
+            this.setState(StateUtil.sortColumn(sortEvent, this._state.value));
+        }
+    }
+    clearSort(column) {
+        this.setState(StateUtil.clearSort(column, this._state.value));
+    }
+    clearAllSort() {
+        this.setState(StateUtil.clearAllSort(this._state.value));
+    }
+    clearFilter(column) {
+        const state = this._state.value;
+        if (column !== null && column !== undefined && column.filterable) {
+            switch (column.filterType) {
+                case FilterType.date:
+                    state.addDateFilter(new DateFilter({
+                        name: column.name,
+                        field: column.filterField,
+                        value: new DateFilterValue(),
+                    }));
+                    break;
+                case FilterType.string:
+                    state.addStringFilter(new StringFilter({
+                        name: column.name,
+                        field: column.filterField,
+                        value: '',
+                    }));
+                    break;
+                case FilterType.number:
+                    state.addNumericFilter(new NumericFilter({
+                        name: column.name,
+                        field: column.filterField,
+                        value: new NumericFilterValue(),
+                    }));
+                    break;
+                case FilterType.list:
+                    state.addListFilter(new ListFilter({
+                        name: column.name,
+                        field: column.filterField,
+                        value: [],
+                        type: ListFilterType.None,
+                    }));
+                    break;
+            }
+            this.setState(new FilterState(state));
+        }
+    }
+    clearAllFilters() {
+        const state = this._state.value;
+        state.stringFilters = [];
+        state.listFilters = [];
+        state.numericFilters = [];
+        state.dateFilters = [];
+        this.setState(new FilterState(state));
+    }
+    pinColumn(column) {
+        this.displayColumns.forEach((col) => {
+            if (col.name === column.name) {
+                col.locked = !col.locked;
+            }
+        });
+        this.updateColumns(this.displayColumns);
+    }
+    dragStart(column) {
+        this._dragSource = column;
+    }
+    lockPreviousColumns(column, element) {
+        const flat = ArrayUtil.flatten(this.displayColumns, 'columns', true).sort((a, b) => Number(b.locked) - Number(a.locked));
+        const index = flat.indexOf(column);
+        const previous = flat.slice(0, index).filter((_) => _.flex > 0);
+        if (previous?.length > 0) {
+            const tableElement = this.getTableElement(element);
+            previous.forEach((item) => {
+                const itemCol = tableElement.querySelector(`teta-head-cell[data-column=${item.name}]`);
+                if (itemCol) {
+                    item.flex = 0;
+                    item.width = itemCol.clientWidth;
+                }
+            });
+        }
+    }
+    resizeColumn(event) {
+        if (event.column !== null && event.column !== undefined) {
+            event.column.width = event.newWidth < 50 ? 50 : event.newWidth;
+            event.column.flex = 0;
+        }
+        this._columns.next(this.displayColumns);
+        this.saveColumnsState();
+    }
+    autosizeColumn(column, target) {
+        const tableElement = this.getTableElement(target);
+        this.setColumnAutoWidth(column, tableElement);
+        this._columns.next(this.displayColumns);
+        this.saveColumnsState();
+    }
+    autosizeAllColumns(target) {
+        const tableElement = this.getTableElement(target);
+        const flat = ArrayUtil.flatten(this.displayColumns, 'columns', true);
+        flat.forEach((col) => this.setColumnAutoWidth(col, tableElement));
+        this._columns.next(this.displayColumns);
+        this.saveColumnsState();
+    }
+    reorderColumn(column, insertBefore) {
+        const event = new ColumnReorderEvent(this._dragSource, column);
+        if (event.source !== event.target) {
+            const sourceParent = this.findParent(event.source, this.displayColumns);
+            const targetParent = this.findParent(event.target, this.displayColumns);
+            if (sourceParent && targetParent) {
+                const sourceIndex = sourceParent.indexOf(event.source);
+                sourceParent.splice(sourceIndex, 1);
+                let targetIndex = targetParent.indexOf(event.target);
+                if (!insertBefore) {
+                    targetIndex = targetIndex + 1;
+                }
+                targetParent.splice(targetIndex, 0, event.source);
+                event.source.locked = event.target.locked;
+                this.updateColumns(this.displayColumns);
+            }
+        }
+    }
+    startEditRow(cellCoordinates) {
+        if (this._currentEditRow?.row !== cellCoordinates?.row) {
+            if (this._currentEditRow != null) {
+                this._editRowStop.next(this._currentEditRow);
+            }
+            if (cellCoordinates === null) {
+                this._editRowStart.next(cellCoordinates);
+                this._currentEditRow = cellCoordinates;
+            }
+            else {
+                if (this.boolOrFuncCallback(this.rowEditable)(cellCoordinates.row)) {
+                    this._editRowStart.next(cellCoordinates);
+                    this._currentEditRow = cellCoordinates;
+                }
+            }
+        }
+    }
+    startEditCell(cellCoordinates) {
+        if (this._currentEditCell?.column.name !== cellCoordinates?.column.name ||
+            this._currentEditCell?.row !== cellCoordinates?.row) {
+            if (this._currentEditCell != null) {
+                this._editCellStop.next(this._currentEditCell);
+            }
+            if (this.boolOrFuncCallback(cellCoordinates.column.editable)(cellCoordinates)) {
+                this._editCellStart.next(cellCoordinates);
+                this._currentEditCell = cellCoordinates;
+            }
+        }
+    }
+    setActiveRow(row) {
+        this._activeRow.next(row);
+    }
+    selectRows(rows) {
+        this._selectedRows.next(rows);
+    }
+    selectRow(row) {
+        if (this.selectType === SelectType.none) {
+            return;
+        }
+        if (this.selectType === SelectType.single) {
+            this._selectedRows.next([row]);
+        }
+        else {
+            this._selectedRows.next([...this._selectedRows.value, row]);
+        }
+    }
+    deselectRow(row) {
+        if (this.selectType === SelectType.none) {
+            return;
+        }
+        if (this.selectType === SelectType.single) {
+            this._selectedRows.next([]);
+        }
+        else {
+            this._selectedRows.next(this._selectedRows.value.filter((_) => _ !== row));
+        }
+    }
+    selectAll() {
+        this._selectedRows.next(this._displayData.value);
+    }
+    deselectAll() {
+        this._selectedRows.next([]);
+    }
+    allRowsSelected() {
+        if (this._displayData.value?.length &&
+            this._selectedRows.value?.length &&
+            this._displayData.value.every((_) => this._selectedRows.value.indexOf(_) >= 0)) {
+            return true;
+        }
+        else if (this._selectedRows.value == null ||
+            this._selectedRows.value.length === 0) {
+            return false;
+        }
+        return null;
+    }
+    setHiddenColumns(value) {
+        this.saveHiddenColumns(value);
+        this._hiddenColumns.next(value);
+    }
+    columnIsHidden(column) {
+        return this._hiddenColumns.value.indexOf(column.name) >= 0;
+    }
+    toggleGroup(row) {
+        this._groupToggle.next(row);
+    }
+    changeValue(coordinates) {
+        this._valueChanged.next(coordinates);
+    }
+    setValue(cellValue) {
+        this._valueSet.next(cellValue);
+    }
+    getRowByIndex(rowIndex) {
+        return this._displayData.value[parseInt(rowIndex, 10)];
+    }
+    getColumnByName(columnName) {
+        return ArrayUtil.findRecursive(this.displayColumns, (iterableNode) => columnName === iterableNode.name, 'columns');
+    }
+    scrollToIndex(index) {
+        this._scrollIndex.next(null);
+        this._scrollIndex.next(index);
+    }
+    boolOrFuncCallback(variable) {
+        return (args) => {
+            if (typeof variable === 'boolean') {
+                return variable;
+            }
+            else if (this.isFunction(variable)) {
+                return variable(args);
+            }
+            return true;
+        };
+    }
+    findParent(column, columns) {
+        const found = columns.find((x) => x.name === column.name);
+        if (found !== null && found !== undefined) {
+            return columns;
+        }
+        for (let i = 0, l = columns.length; i < l; i++) {
+            const col = columns[i];
+            if (col.columns && col.columns.length) {
+                const result = this.findParent(column, col.columns);
+                if (result !== null && result !== undefined) {
+                    return result;
+                }
+            }
+        }
+        return null;
+    }
+    getTableElement(element) {
+        return element.closest('teta-table');
+    }
+    isFunction(obj) {
+        return !!(obj && obj?.constructor && obj?.call && obj?.apply);
+    }
+    setColumnAutoWidth(column, table) {
+        const cells = table.querySelectorAll(`teta-cell[data-column=${column.name}] .cell-text`);
+        let maxWidth = 0;
+        cells.forEach((cell) => {
+            if (cell.scrollWidth > maxWidth) {
+                maxWidth = cell.scrollWidth;
+            }
+        });
+        column.flex = 0;
+        column.width = maxWidth + 20;
+    }
+}
+TableService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: TableService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TableService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: TableService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: TableService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.service.js","sourceRoot":"","sources":["../../../../../src/component/table/service/table.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {TableRow} from '../contract/table-row';\nimport {ICellCoordinates} from '../contract/i-cell-coordinates';\nimport {TableColumn} from '../contract/table-column';\nimport {FilterState} from '../../filter/contarct/filter-state';\nimport {BehaviorSubject, Observable, Subject} from 'rxjs';\nimport {ColumnResizeEvent} from '../contract/column-resize-event';\nimport {ColumnReorderEvent} from '../contract/column-reorder-event';\nimport {SortEvent} from '../contract/sort-event';\nimport {ArrayUtil} from '../../../common/util/array-util';\nimport {StateUtil} from '../util/state-util';\nimport {SelectType} from '../enum/select-type.enum';\nimport {EditType} from '../enum/edit-type.enum';\nimport {EditEvent} from '../enum/edit-event.enum';\nimport {ListFilterType} from '../../filter/enum/list-filter-type.enum';\nimport {ListFilter} from '../../filter/contarct/list-filter';\nimport {FilterType} from '../../filter/enum/filter-type.enum';\nimport {NumericFilterValue} from '../../filter/contarct/numeric-filter-value';\nimport {NumericFilter} from '../../filter/contarct/numeric-filter';\nimport {StringFilter} from '../../filter/contarct/string-filter';\nimport {DateFilterValue} from '../../filter/contarct/date-filter-value';\nimport {DateFilter} from '../../filter/contarct/date-filter';\nimport {IDictionary} from '../../../common/contract/i-dictionary';\nimport {IIdName} from '../../../common/contract/i-id-name';\nimport {DateUtil} from '../../../util/date-util';\nimport objectHash from 'object-hash';\nimport {TableColumnStore} from '../contract/table-column-store';\nimport {ICellValue} from '../contract/i-cell-value';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class TableService<T> {\n  columns: Observable<TableColumn[]>;\n  displayData: Observable<TableRow<T>[]>;\n  dict: Observable<IDictionary<IIdName<any>[]>>;\n  state: Observable<FilterState>;\n  selectType: SelectType;\n  editRowStart: Observable<ICellCoordinates<T>>;\n  editRowStop: Observable<ICellCoordinates<T>>;\n\n  editCellStart: Observable<ICellCoordinates<T>>;\n  editCellStop: Observable<ICellCoordinates<T>>;\n  valueChanged: Observable<ICellCoordinates<T>>;\n  valueSet: Observable<ICellValue<T>>;\n  stateChanged: Observable<FilterState>;\n  filterClear: Observable<TableColumn>;\n  groupToggle: Observable<TableRow<T>>;\n  selectedRows: Observable<TableRow<T>[]>;\n  activeRow: Observable<TableRow<T>>;\n  hiddenColumns: Observable<string[]>;\n  scrollIndex: Observable<number>;\n\n  editType: EditType;\n  editEvent: EditEvent;\n  rowEditable: boolean | ((row: TableRow<T>) => boolean);\n  // cellEditable: boolean | ((row: ICellCoordinates<T>) => boolean);\n\n  get dragSource() {\n    return this._dragSource;\n  }\n\n  private initialColumnsHash: string;\n  private initialColumns: TableColumn[] = [];\n  private displayColumns: TableColumn[] = [];\n  private _columns: BehaviorSubject<TableColumn[]> = new BehaviorSubject<TableColumn[]>([]);\n  private initialData: TableRow<T>[] = [];\n  private _displayData: BehaviorSubject<TableRow<T>[]> = new BehaviorSubject<TableRow<T>[]>([]);\n  private _dict: BehaviorSubject<IDictionary<IIdName<any>[]>> =\n    new BehaviorSubject<IDictionary<IIdName<any>[]>>({});\n  private _state: BehaviorSubject<FilterState> =\n    new BehaviorSubject<FilterState>(new FilterState());\n  private _cookieName: string;\n  private _hiddenCookieName: string;\n  private _columnsCookieName: string;\n  private _editRowStart = new Subject<ICellCoordinates<T> | null>();\n  private _editRowStop = new Subject<ICellCoordinates<T> | null>();\n  private _editCellStart = new Subject<ICellCoordinates<T> | null>();\n  private _editCellStop = new Subject<ICellCoordinates<T> | null>();\n  private _valueChanged = new Subject<ICellCoordinates<T> | null>();\n  private _valueSet = new Subject<ICellValue<T>>();\n  private _stateChanged = new Subject<FilterState>();\n  private _filterClear = new Subject<TableColumn>();\n  private _dragSource: TableColumn;\n  private _groupToggle = new Subject<TableRow<T>>();\n  private _selectedRows = new BehaviorSubject<TableRow<T>[]>([]);\n  private _activeRow = new BehaviorSubject<TableRow<T>>(null);\n  private _hiddenColumns = new BehaviorSubject<string[]>([]);\n  private _scrollIndex = new Subject<number>();\n\n  private _currentEditRow: ICellCoordinates<T>;\n  private _currentEditCell: ICellCoordinates<T>;\n\n  constructor() {\n    this.columns = this._columns.asObservable();\n    this.displayData = this._displayData.asObservable();\n    this.dict = this._dict.asObservable();\n    this.state = this._state.asObservable();\n    this.editRowStart = this._editRowStart.asObservable();\n    this.editRowStop = this._editRowStop.asObservable();\n    this.editCellStart = this._editCellStart.asObservable();\n    this.editCellStop = this._editCellStop.asObservable();\n    this.valueChanged = this._valueChanged.asObservable();\n    this.valueSet = this._valueSet.asObservable();\n    this.stateChanged = this._stateChanged.asObservable();\n    this.filterClear = this._filterClear.asObservable();\n    this.groupToggle = this._groupToggle.asObservable();\n    this.selectedRows = this._selectedRows.asObservable();\n    this.activeRow = this._activeRow.asObservable();\n    this.hiddenColumns = this._hiddenColumns.asObservable();\n    this.scrollIndex = this._scrollIndex.asObservable();\n  }\n\n  setData(data: T[]): void {\n    this.initialData = data?.map((_) => new TableRow<T>(_));\n    this._displayData.next(this.initialData);\n  }\n\n  setDict(dict: IDictionary<IIdName<any>[]>): void {\n    this._dict.next(dict);\n  }\n\n  setColumns(columns: TableColumn[]): void {\n    this.initialColumns = columns ? columns.map((_) => new TableColumn(_)) : [];\n    this.initialColumnsHash = objectHash(this.initialColumns, {\n      algorithm: 'sha1',\n      ignoreUnknown: true,\n      excludeKeys: key => key === 'headDropdownTemplate',\n    });\n    const restored = this.restoreColumns();\n\n    if (restored) {\n      this.setDisplayColumns(restored);\n    } else {\n      this.setDisplayColumns(this.initialColumns);\n    }\n  }\n\n  restoreDefaultColumns() {\n    this.setDisplayColumns(this.initialColumns);\n    this.clearColumnsState();\n  }\n\n  updateColumns(columns: TableColumn[]): void {\n    this.setDisplayColumns(columns);\n    this.saveColumnsState();\n  }\n\n  saveColumnsState() {\n    if (this._cookieName) {\n      localStorage.setItem(\n        this._columnsCookieName,\n        JSON.stringify({\n          hash: this.initialColumnsHash,\n          columns: this.displayColumns.map((_) => new TableColumnStore(_)),\n        })\n      );\n    }\n  }\n\n  clearColumnsState() {\n    localStorage.removeItem(this._columnsCookieName);\n  }\n\n  setDisplayColumns(columns: TableColumn[]): void {\n    this.displayColumns = columns ? columns.map((_) => new TableColumn(_)) : [];\n    this._columns.next(this.displayColumns);\n  }\n\n  restoreColumns() {\n    const savedColumns = JSON.parse(\n      localStorage.getItem(this._columnsCookieName)\n    );\n    if (savedColumns && savedColumns.hash === this.initialColumnsHash) {\n      return this.restoreColumnsState(savedColumns.columns);\n    }\n    return null;\n  }\n\n  restoreColumnsState(columns: TableColumnStore[]) {\n    return columns.map((column: TableColumnStore) => {\n      const found = ArrayUtil.findRecursive(\n        this.initialColumns,\n        (item) => item.name === column.name,\n        'columns'\n      );\n      const resultColumn = new TableColumn(found);\n      resultColumn.width = column.width;\n      resultColumn.flex = column.flex;\n      resultColumn.locked = column.locked;\n      if (column.columns?.length > 0) {\n        resultColumn.columns = this.restoreColumnsState(column.columns);\n      }\n      return resultColumn;\n    });\n  }\n\n  setState(state: FilterState): void {\n    state.save(this._cookieName);\n    this._state.next(state);\n  }\n\n  setCookieName(name: string): void {\n    this._cookieName = name;\n    this._hiddenCookieName = `${this._cookieName}_hidden_columns`;\n    this._columnsCookieName = `${this._cookieName}_columns`;\n  }\n\n  restoreState(): void {\n    let state: FilterState;\n    if (this._cookieName?.length > 0 && FilterState.restore(this._cookieName)) {\n      let newState = Object.assign(\n        this._state.value,\n        FilterState.restore(this._cookieName)\n      );\n      newState = DateUtil.convertDateStringsToDates(newState);\n      state = new FilterState(newState);\n    } else {\n      state = new FilterState();\n    }\n    this.setState(state);\n  }\n\n  saveHiddenColumns(hiddenColumns: string[]): void {\n    localStorage.setItem(this._hiddenCookieName, JSON.stringify(hiddenColumns));\n  }\n\n  restoreHiddenColumns(): void {\n    const hiddenColumns = localStorage.getItem(this._hiddenCookieName) || '[]';\n    this._hiddenColumns.next(JSON.parse(hiddenColumns));\n  }\n\n  sort(sortEvent: SortEvent): void {\n    if (sortEvent.column.sortable) {\n      this.setState(StateUtil.sortColumn(sortEvent, this._state.value));\n    }\n  }\n\n  clearSort(column: TableColumn): void {\n    this.setState(StateUtil.clearSort(column, this._state.value));\n  }\n\n  clearAllSort(): void {\n    this.setState(StateUtil.clearAllSort(this._state.value));\n  }\n\n  clearFilter(column: TableColumn) {\n    const state = this._state.value;\n    if (column !== null && column !== undefined && column.filterable) {\n      switch (column.filterType) {\n        case FilterType.date:\n          state.addDateFilter(\n            new DateFilter({\n              name: column.name,\n              field: column.filterField,\n              value: new DateFilterValue(),\n            })\n          );\n          break;\n        case FilterType.string:\n          state.addStringFilter(\n            new StringFilter({\n              name: column.name,\n              field: column.filterField,\n              value: '',\n            })\n          );\n          break;\n        case FilterType.number:\n          state.addNumericFilter(\n            new NumericFilter({\n              name: column.name,\n              field: column.filterField,\n              value: new NumericFilterValue(),\n            })\n          );\n          break;\n        case FilterType.list:\n          state.addListFilter(\n            new ListFilter({\n              name: column.name,\n              field: column.filterField,\n              value: [],\n              type: ListFilterType.None,\n            })\n          );\n          break;\n      }\n      this.setState(new FilterState(state));\n    }\n  }\n\n  clearAllFilters() {\n    const state = this._state.value;\n    state.stringFilters = [];\n    state.listFilters = [];\n    state.numericFilters = [];\n    state.dateFilters = [];\n    this.setState(new FilterState(state));\n  }\n\n  pinColumn(column: TableColumn): void {\n    this.displayColumns.forEach((col: TableColumn) => {\n      if (col.name === column.name) {\n        col.locked = !col.locked;\n      }\n    });\n    this.updateColumns(this.displayColumns);\n  }\n\n  dragStart(column: TableColumn): void {\n    this._dragSource = column;\n  }\n\n  lockPreviousColumns(column: TableColumn, element: HTMLElement) {\n    const flat = ArrayUtil.flatten(this.displayColumns, 'columns', true).sort(\n      (a, b) => Number(b.locked) - Number(a.locked)\n    );\n    const index = flat.indexOf(column);\n    const previous = flat.slice(0, index).filter((_) => _.flex > 0);\n    if (previous?.length > 0) {\n      const tableElement = this.getTableElement(element);\n      previous.forEach((item: TableColumn) => {\n        const itemCol = tableElement.querySelector(\n          `teta-head-cell[data-column=${item.name}]`\n        ) as HTMLElement;\n        if (itemCol) {\n          item.flex = 0;\n          item.width = itemCol.clientWidth;\n        }\n      });\n    }\n  }\n\n  resizeColumn(event: ColumnResizeEvent) {\n    if (event.column !== null && event.column !== undefined) {\n      event.column.width = event.newWidth < 50 ? 50 : event.newWidth;\n      event.column.flex = 0;\n    }\n    this._columns.next(this.displayColumns);\n    this.saveColumnsState();\n  }\n\n  autosizeColumn(column: TableColumn, target: HTMLElement) {\n    const tableElement = this.getTableElement(target);\n    this.setColumnAutoWidth(column, tableElement as HTMLElement);\n    this._columns.next(this.displayColumns);\n    this.saveColumnsState();\n  }\n\n  autosizeAllColumns(target: HTMLElement) {\n    const tableElement = this.getTableElement(target);\n    const flat = ArrayUtil.flatten(this.displayColumns, 'columns', true);\n    flat.forEach((col) =>\n      this.setColumnAutoWidth(col, tableElement as HTMLElement)\n    );\n    this._columns.next(this.displayColumns);\n    this.saveColumnsState();\n  }\n\n  reorderColumn(column: TableColumn, insertBefore: boolean): void {\n    const event = new ColumnReorderEvent(this._dragSource, column);\n    if (event.source !== event.target) {\n      const sourceParent = this.findParent(event.source, this.displayColumns);\n      const targetParent = this.findParent(event.target, this.displayColumns);\n\n      if (sourceParent && targetParent) {\n        const sourceIndex = sourceParent.indexOf(event.source);\n        sourceParent.splice(sourceIndex, 1);\n        let targetIndex = targetParent.indexOf(event.target);\n        if (!insertBefore) {\n          targetIndex = targetIndex + 1;\n        }\n        targetParent.splice(targetIndex, 0, event.source);\n        event.source.locked = event.target.locked;\n\n        this.updateColumns(this.displayColumns);\n      }\n    }\n  }\n\n  startEditRow(cellCoordinates: ICellCoordinates<T>): void {\n    if (this._currentEditRow?.row !== cellCoordinates?.row) {\n      if (this._currentEditRow != null) {\n        this._editRowStop.next(this._currentEditRow);\n      }\n      if (cellCoordinates === null) {\n        this._editRowStart.next(cellCoordinates);\n        this._currentEditRow = cellCoordinates;\n      } else {\n        if (\n          this.boolOrFuncCallback<TableRow<T>>(this.rowEditable)(\n            cellCoordinates.row\n          )\n        ) {\n          this._editRowStart.next(cellCoordinates);\n          this._currentEditRow = cellCoordinates;\n        }\n      }\n    }\n  }\n\n  startEditCell(cellCoordinates: ICellCoordinates<T>): void {\n    if (\n      this._currentEditCell?.column.name !== cellCoordinates?.column.name ||\n      this._currentEditCell?.row !== cellCoordinates?.row\n    ) {\n      if (this._currentEditCell != null) {\n        this._editCellStop.next(this._currentEditCell);\n      }\n      if (\n        this.boolOrFuncCallback<ICellCoordinates<T>>(cellCoordinates.column.editable)(\n          cellCoordinates\n        )\n      ) {\n        this._editCellStart.next(cellCoordinates);\n        this._currentEditCell = cellCoordinates;\n      }\n    }\n  }\n\n  setActiveRow(row: TableRow<T>): void {\n    this._activeRow.next(row);\n  }\n\n  selectRows(rows: TableRow<T>[]): void {\n    this._selectedRows.next(rows);\n  }\n\n  selectRow(row: TableRow<T>): void {\n    if (this.selectType === SelectType.none) {\n      return;\n    }\n    if (this.selectType === SelectType.single) {\n      this._selectedRows.next([row]);\n    } else {\n      this._selectedRows.next([...this._selectedRows.value, row]);\n    }\n  }\n\n  deselectRow(row: TableRow<T>): void {\n    if (this.selectType === SelectType.none) {\n      return;\n    }\n    if (this.selectType === SelectType.single) {\n      this._selectedRows.next([]);\n    } else {\n      this._selectedRows.next(\n        this._selectedRows.value.filter((_) => _ !== row)\n      );\n    }\n  }\n\n  selectAll() {\n    this._selectedRows.next(this._displayData.value);\n  }\n\n  deselectAll() {\n    this._selectedRows.next([]);\n  }\n\n  allRowsSelected(): boolean | null {\n    if (\n      this._displayData.value?.length &&\n      this._selectedRows.value?.length &&\n      this._displayData.value.every(\n        (_) => this._selectedRows.value.indexOf(_) >= 0\n      )\n    ) {\n      return true;\n    } else if (\n      this._selectedRows.value == null ||\n      this._selectedRows.value.length === 0\n    ) {\n      return false;\n    }\n    return null;\n  }\n\n  setHiddenColumns(value: string[]) {\n    this.saveHiddenColumns(value);\n    this._hiddenColumns.next(value);\n  }\n\n  columnIsHidden(column: TableColumn) {\n    return this._hiddenColumns.value.indexOf(column.name) >= 0;\n  }\n\n  toggleGroup(row: TableRow<T>): void {\n    this._groupToggle.next(row);\n  }\n\n  changeValue(coordinates: ICellCoordinates<T>): void {\n    this._valueChanged.next(coordinates);\n  }\n\n  setValue(cellValue: ICellValue<T>): void {\n    this._valueSet.next(cellValue);\n  }\n\n  getRowByIndex(rowIndex: string) {\n    return this._displayData.value[parseInt(rowIndex, 10)];\n  }\n\n  getColumnByName(columnName: string) {\n    return ArrayUtil.findRecursive(\n      this.displayColumns,\n      (iterableNode) => columnName === iterableNode.name,\n      'columns'\n    );\n  }\n\n  scrollToIndex(index: number) {\n    this._scrollIndex.next(null);\n    this._scrollIndex.next(index);\n  }\n\n  boolOrFuncCallback<M>(variable: boolean | ((row: M) => boolean)) {\n    return (args: M) => {\n      if (typeof variable === 'boolean') {\n        return variable;\n      } else if (this.isFunction(variable)) {\n        return (variable as (row: M) => boolean)(args);\n      }\n      return true;\n    };\n  }\n\n  private findParent(\n    column: TableColumn,\n    columns: TableColumn[]\n  ): TableColumn[] | null {\n    const found = columns.find((x) => x.name === column.name);\n    if (found !== null && found !== undefined) {\n      return columns;\n    }\n    for (let i = 0, l = columns.length; i < l; i++) {\n      const col = columns[i];\n      if (col.columns && col.columns.length) {\n        const result = this.findParent(column, col.columns);\n        if (result !== null && result !== undefined) {\n          return result;\n        }\n      }\n    }\n    return null;\n  }\n\n  private getTableElement(element: HTMLElement) {\n    return element.closest('teta-table');\n  }\n\n  private isFunction(obj: any) {\n    return !!(obj && obj?.constructor && obj?.call && obj?.apply);\n  }\n\n  private setColumnAutoWidth(column: TableColumn, table: HTMLElement) {\n    const cells = table.querySelectorAll(\n      `teta-cell[data-column=${column.name}] .cell-text`\n    );\n    let maxWidth = 0;\n    cells.forEach((cell) => {\n      if (cell.scrollWidth > maxWidth) {\n        maxWidth = cell.scrollWidth;\n      }\n    });\n    column.flex = 0;\n    column.width = maxWidth + 20;\n  }\n}\n"]}