@tetacom/ng-components 1.1.1 → 1.1.3

package/esm2022/component/table/table/table.component.mjs

@@ -0,0 +1,491 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, HostBinding, HostListener, Input, Output, ViewChild, } from '@angular/core';
+import { TableService } from '../service/table.service';
+import { filter, takeWhile } from 'rxjs/operators';
+import { EditType } from '../enum/edit-type.enum';
+import { EditEvent } from '../enum/edit-event.enum';
+import { SelectType } from '../enum/select-type.enum';
+import { FilterType } from '../../filter/enum/filter-type.enum';
+import { VerticalAlign } from '../../../common/enum/vertical-align.enum';
+import { Align } from '../../../common/enum/align.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../service/table.service";
+import * as i2 from "../../../directive/context-menu/context-menu.directive";
+import * as i3 from "../table-head/table-head.component";
+import * as i4 from "../table-body/table-body.component";
+export class TableComponent {
+    _svc;
+    _elementRef;
+    data = [];
+    columns = [];
+    dict;
+    filterOptions;
+    set state(state) {
+        this._state = state;
+    }
+    cookieName;
+    virtual;
+    detailComponent;
+    activeRow;
+    selectedRows;
+    selectType = SelectType.mouse;
+    aggregate;
+    trackRow = (index, row) => {
+        if (row['id']) {
+            return row['id'];
+        }
+        return index;
+    };
+    trackColumns = (index, column) => {
+        return column.name;
+    };
+    editType = EditType.cell;
+    editEvent = EditEvent.doubleClick;
+    rowEditable;
+    rowClass;
+    set scrollToIndex(index) {
+        this._svc.scrollToIndex(index);
+    }
+    showHeadCellMenu = true;
+    contextMenu;
+    contextMenuOpen;
+    contextMenuOpenChange = new EventEmitter();
+    stateChange = new EventEmitter();
+    bodyLeft = new EventEmitter();
+    activeRowChange = new EventEmitter();
+    selectedRowsChange = new EventEmitter();
+    cellClick = new EventEmitter();
+    cellDoubleClick = new EventEmitter();
+    cellFocus = new EventEmitter();
+    cellKeyDown = new EventEmitter();
+    rowLeft = new EventEmitter();
+    rowEditStart = new EventEmitter();
+    rowEditEnd = new EventEmitter();
+    cellEditStart = new EventEmitter();
+    cellEditEnd = new EventEmitter();
+    valueChange = new EventEmitter();
+    tableService = new EventEmitter();
+    menu;
+    tableClass = true;
+    selectedRowsList;
+    contextMenuRow;
+    verticalAlign = VerticalAlign;
+    align = Align;
+    _alive = true;
+    _headElement;
+    _state;
+    constructor(_svc, _elementRef) {
+        this._svc = _svc;
+        this._elementRef = _elementRef;
+        this._svc.state
+            .pipe(takeWhile((_) => this._alive), filter((state) => state !== this._state))
+            .subscribe((state) => this.stateChange.next(state));
+        this._svc.editCellStart
+            .pipe(takeWhile((_) => this._alive))
+            .subscribe((item) => this.cellEditStart.emit(this._svc.getCellInstance(item)));
+        this._svc.editCellStop
+            .pipe(takeWhile((_) => this._alive))
+            .subscribe((item) => this.cellEditEnd.emit(this._svc.getCellInstance(item)));
+        this._svc.editRowStart
+            .pipe(takeWhile((_) => this._alive))
+            .subscribe((item) => this.rowEditStart.emit(this._svc.getCellInstance(item)));
+        this._svc.editRowStop
+            .pipe(takeWhile((_) => this._alive))
+            .subscribe((item) => this.rowEditEnd.emit(this._svc.getRowByIndex(item?.row)));
+        this._svc.selectedRows
+            .pipe(takeWhile((_) => this._alive))
+            .subscribe((items) => {
+            this.selectedRowsList = items;
+            this.selectedRowsChange.emit(items);
+        });
+        this._svc.activeRow
+            .pipe(takeWhile((_) => this._alive))
+            .subscribe((item) => {
+            this.activeRow = item;
+            this.activeRowChange.emit(item);
+        });
+        this._svc.valueChanged
+            .pipe(takeWhile((_) => this._alive))
+            .subscribe((coordinates) => {
+            this.valueChange.emit(this._svc.getCellInstance(coordinates));
+        });
+    }
+    handleClickOutsideAnyRow(event) {
+        const coordinates = this.getCoordinates(event);
+        const row = this.getRow(event);
+        const eventIsOnRow = this.eventIsOnRow(event);
+        setTimeout(() => {
+            if (coordinates) {
+                this.cellClick.emit({
+                    ...this._svc.getCellInstance(coordinates),
+                    event
+                });
+                if (this.editEvent === EditEvent.click) {
+                    this.startEditRowOrCell(coordinates);
+                }
+                else {
+                    if (this._svc.currentEditCell && (coordinates.row !== this._svc.currentEditCell.row || coordinates.column !== this._svc.currentEditCell.column)) {
+                        this.startEditRowOrCell(null);
+                    }
+                }
+            }
+            if (row) {
+                if (event.ctrlKey) {
+                    this._svc.selectOrDeselectRow(row);
+                }
+                else if (event.shiftKey) {
+                    this._svc.selectRange(row);
+                }
+                else {
+                    this._svc.selectRows([row]);
+                }
+            }
+            if (!eventIsOnRow && !event.defaultPrevented) {
+                if (this.editType === EditType.row) {
+                    this._svc.startEditRow(null);
+                }
+                else {
+                    this._svc.startEditCell(null);
+                }
+            }
+        });
+    }
+    focusIn(event) {
+        const coordinates = this.getCoordinates(event);
+        if (coordinates) {
+            this.cellFocus.emit({
+                ...this._svc.getCellInstance(coordinates),
+                event
+            });
+            if (this.editEvent === EditEvent.focus) {
+                this.startEditRowOrCell(coordinates);
+            }
+        }
+    }
+    dblclick(event) {
+        const coordinates = this.getCoordinates(event);
+        if (coordinates) {
+            setTimeout(() => {
+                this.cellDoubleClick.emit({
+                    ...this._svc.getCellInstance(coordinates),
+                    event
+                });
+                if (this.editEvent === EditEvent.doubleClick) {
+                    this.startEditRowOrCell(coordinates);
+                }
+            });
+        }
+    }
+    keydown(event) {
+        if (event.ctrlKey) {
+            if (event.code === 'KeyA') {
+                event.preventDefault();
+                this._svc.selectAll();
+            }
+            return;
+        }
+        if (event.key === 'Escape') {
+            this._svc.deselectAll();
+            if (this.editType === EditType.row) {
+                this._svc.startEditRow(null);
+            }
+            else {
+                this._svc.startEditCell(null);
+            }
+        }
+        const coordinates = this.getCoordinates(event);
+        if (event.key === 'Enter') {
+            if (this.editType === EditType.row) {
+                this._svc.startEditRow(null);
+            }
+            else {
+                if (this._svc.currentEditCell) {
+                    const target = this._svc.getNextRowCell(coordinates);
+                    if (target) {
+                        this.startEditRowOrCell({
+                            row: target.row,
+                            column: target.column,
+                            event: undefined
+                        });
+                    }
+                    else {
+                        this._svc.startEditCell(null);
+                    }
+                }
+            }
+        }
+        if (coordinates) {
+            this.cellKeyDown.emit({
+                ...this._svc.getCellInstance(coordinates),
+                event
+            });
+            if (event.key && (event.key.length === 1 || event.key === 'Delete')) {
+                const column = this._svc.getColumnByName(coordinates.column);
+                if (column.filterType !== FilterType.number || isFinite(event.key)) {
+                    this.startEditRowOrCell({
+                        row: coordinates.row,
+                        column: coordinates.column,
+                        event: event
+                    });
+                }
+            }
+            if (event.key === 'Tab' && this._svc.currentEditCell) {
+                event.preventDefault();
+                let target = this._svc.getNextEditableCell(coordinates);
+                if (event.shiftKey) {
+                    target = this._svc.getPreviousEditableCell(coordinates);
+                }
+                if (target) {
+                    this.startEditRowOrCell({
+                        row: target.row,
+                        column: target.column,
+                        event: undefined
+                    });
+                }
+            }
+            if (!this._svc.currentEditCell) {
+                let target;
+                if (event.key === 'ArrowRight') {
+                    target = this._svc.getNextCell(coordinates);
+                }
+                if (event.key === 'ArrowLeft') {
+                    target = this._svc.getPreviousCell(coordinates);
+                }
+                if (event.key === 'ArrowUp') {
+                    target = this._svc.getPreviousRowCell(coordinates);
+                }
+                if (event.key === 'ArrowDown') {
+                    target = this._svc.getNextRowCell(coordinates);
+                }
+                if (target) {
+                    event.preventDefault();
+                    const element = this.getCellElement(target);
+                    element?.focus();
+                }
+            }
+        }
+    }
+    mousedown(event) {
+        if (event.button === 2) {
+            event.preventDefault();
+        }
+    }
+    ngOnInit() {
+        this._svc.restoreState();
+        this._svc.restoreHiddenColumns();
+        this.tableService.emit(this._svc);
+    }
+    ngAfterViewInit() {
+        this._headElement =
+            this._elementRef.nativeElement.querySelector('.table-head');
+    }
+    ngOnDestroy() {
+        this._alive = false;
+    }
+    ngOnChanges(changes) {
+        if (changes.hasOwnProperty('editType')) {
+            this._svc.editType = this.editType;
+        }
+        if (changes.hasOwnProperty('selectType')) {
+            this._svc.selectType = this.selectType;
+        }
+        if (changes.hasOwnProperty('selectedRows')) {
+            this._svc.selectRows(this.selectedRows);
+        }
+        if (changes.hasOwnProperty('rowEditable')) {
+            this._svc.rowEditable = this.rowEditable;
+        }
+        if (changes.hasOwnProperty('cookieName')) {
+            this._svc.setCookieName(this.cookieName);
+        }
+        if (changes.hasOwnProperty('columns')) {
+            if (this.columns !== null && this.columns !== undefined) {
+                this._svc.setColumns(this.columns);
+            }
+        }
+        if (changes.hasOwnProperty('data')) {
+            this._svc.setData(this.data);
+            this._svc.selectRows(this.data?.filter((row) => {
+                return this.selectedRows?.some((selectedRow) => this.trackRow(this._svc.getRowIndex(selectedRow), selectedRow) === this.trackRow(this._svc.getRowIndex(row), row));
+            }));
+        }
+        if (changes.hasOwnProperty('dict')) {
+            this._svc.setDict(this.dict);
+            this._svc.setFilterOptions(this.dict);
+        }
+        if (changes.hasOwnProperty('filterOptions')) {
+            this._svc.setFilterOptions(this.filterOptions);
+        }
+        if (changes.hasOwnProperty('trackRow')) {
+            this._svc.trackRow = this.trackRow;
+        }
+    }
+    setContextMenuOpen(value) {
+        this.contextMenuOpen = value;
+        this.contextMenuOpenChange.emit(this.contextMenuOpen);
+    }
+    setContextMenuRow(event) {
+        this.contextMenuRow = null;
+        const rowElement = this._svc.getEventRow(event);
+        if (rowElement) {
+            const rowIndex = parseInt(rowElement.getAttribute('data-row'), 10);
+            if (rowIndex >= 0) {
+                this.contextMenuRow = this._svc.getRowByIndex(rowIndex);
+            }
+        }
+    }
+    startEditRowOrCell(coordinates) {
+        if (this.editType === EditType.row) {
+            this._svc.startEditRow(coordinates);
+        }
+        if (this.editType === EditType.cell) {
+            this._svc.startEditCell(coordinates);
+        }
+    }
+    getCellElement(coordinates) {
+        return this._elementRef.nativeElement.querySelector(`teta-cell[data-row="${coordinates.row}"][data-column="${coordinates.column}"]`);
+    }
+    eventIsOnRow(event) {
+        const row = event.composedPath().find((target) => {
+            return target?.getAttribute && target?.getAttribute('data-row');
+        });
+        return row && this._elementRef.nativeElement.contains(row);
+    }
+    getCoordinates(event) {
+        if (event.composedPath().indexOf(this._elementRef.nativeElement) < 0) {
+            return null;
+        }
+        const cell = this._svc.getEventCell(event);
+        if (cell) {
+            const rowIndex = parseInt(cell.getAttribute('data-row'), 10);
+            const columnName = cell.getAttribute('data-column');
+            if (rowIndex >= 0 && columnName) {
+                return {
+                    row: rowIndex,
+                    column: columnName,
+                    event,
+                };
+            }
+        }
+        return null;
+    }
+    getRow(event) {
+        if (event.composedPath().indexOf(this._elementRef.nativeElement) < 0) {
+            return null;
+        }
+        const rowElement = this._svc.getEventRow(event);
+        if (rowElement) {
+            const rowIndex = parseInt(rowElement.getAttribute('data-row'), 10);
+            if (rowIndex >= 0) {
+                return this._svc.getRowByIndex(rowIndex);
+            }
+        }
+        return null;
+    }
+    onScroll = (event) => {
+        this._headElement.scrollLeft = event.target.scrollLeft;
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: TableComponent, deps: [{ token: i1.TableService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: TableComponent, selector: "teta-table", inputs: { data: "data", columns: "columns", dict: "dict", filterOptions: "filterOptions", state: "state", cookieName: "cookieName", virtual: "virtual", detailComponent: "detailComponent", activeRow: "activeRow", selectedRows: "selectedRows", selectType: "selectType", aggregate: "aggregate", trackRow: "trackRow", trackColumns: "trackColumns", editType: "editType", editEvent: "editEvent", rowEditable: "rowEditable", rowClass: "rowClass", scrollToIndex: "scrollToIndex", showHeadCellMenu: "showHeadCellMenu", contextMenu: "contextMenu", contextMenuOpen: "contextMenuOpen" }, outputs: { contextMenuOpenChange: "contextMenuOpenChange", stateChange: "stateChange", bodyLeft: "bodyLeft", activeRowChange: "activeRowChange", selectedRowsChange: "selectedRowsChange", cellClick: "cellClick", cellDoubleClick: "cellDoubleClick", cellFocus: "cellFocus", cellKeyDown: "cellKeyDown", rowLeft: "rowLeft", rowEditStart: "rowEditStart", rowEditEnd: "rowEditEnd", cellEditStart: "cellEditStart", cellEditEnd: "cellEditEnd", valueChange: "valueChange", tableService: "tableService" }, host: { listeners: { "document:click": "handleClickOutsideAnyRow($event)", "focusin": "focusIn($event)", "dblclick": "dblclick($event)", "keydown": "keydown($event)", "mousedown": "mousedown($event)" }, properties: { "class.table": "this.tableClass" } }, providers: [TableService], viewQueries: [{ propertyName: "menu", first: true, predicate: ["contextMenu"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: "<div class=\"column column_auto\">\n  <teta-table-head\n    style=\"z-index: 1\"\n    [selectType]=\"selectType\"\n    [showHeadCellMenu]=\"showHeadCellMenu\"></teta-table-head>\n  <div class=\"column column_auto position-relative\"\n       style=\"z-index: 0\"\n       [tetaContextMenu]=\"contextMenu\"\n       [verticalAlign]=\"verticalAlign.auto\"\n       [align]=\"align.auto\"\n       [appendToBody]=\"true\"\n       [data]=\"contextMenuRow\"\n       [open]=\"contextMenuOpen\"\n       (openChange)=\"setContextMenuOpen($event)\">\n    <teta-table-body\n      (contextmenu)=\"setContextMenuRow($event)\"\n      (scroll)=\"onScroll($event)\"\n      [aggregate]=\"aggregate\"\n      [virtual]=\"virtual\"\n      [activeRow]=\"activeRow\"\n      [trackRow]=\"trackRow\"\n      [trackColumns]=\"trackColumns\"\n      [selectedRows]=\"selectedRowsList\"\n      [additionalComponent]=\"detailComponent\"\n      [selectType]=\"selectType\"\n      [rowClass]=\"rowClass\">\n      <ng-content></ng-content>\n    </teta-table-body>\n  </div>\n</div>\n", styles: [""], dependencies: [{ kind: "directive", type: i2.ContextMenuDirective, selector: "[tetaContextMenu]", inputs: ["tetaContextMenu", "autoCloseIgnore"] }, { kind: "component", type: i3.TableHeadComponent, selector: "teta-table-head", inputs: ["selectType", "showHeadCellMenu"] }, { kind: "component", type: i4.TableBodyComponent, selector: "teta-table-body", inputs: ["virtual", "activeRow", "selectedRows", "additionalComponent", "aggregate", "selectType", "rowClass", "trackRow", "trackColumns"], outputs: ["scroll"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: TableComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'teta-table', changeDetection: ChangeDetectionStrategy.OnPush, providers: [TableService], template: "<div class=\"column column_auto\">\n  <teta-table-head\n    style=\"z-index: 1\"\n    [selectType]=\"selectType\"\n    [showHeadCellMenu]=\"showHeadCellMenu\"></teta-table-head>\n  <div class=\"column column_auto position-relative\"\n       style=\"z-index: 0\"\n       [tetaContextMenu]=\"contextMenu\"\n       [verticalAlign]=\"verticalAlign.auto\"\n       [align]=\"align.auto\"\n       [appendToBody]=\"true\"\n       [data]=\"contextMenuRow\"\n       [open]=\"contextMenuOpen\"\n       (openChange)=\"setContextMenuOpen($event)\">\n    <teta-table-body\n      (contextmenu)=\"setContextMenuRow($event)\"\n      (scroll)=\"onScroll($event)\"\n      [aggregate]=\"aggregate\"\n      [virtual]=\"virtual\"\n      [activeRow]=\"activeRow\"\n      [trackRow]=\"trackRow\"\n      [trackColumns]=\"trackColumns\"\n      [selectedRows]=\"selectedRowsList\"\n      [additionalComponent]=\"detailComponent\"\n      [selectType]=\"selectType\"\n      [rowClass]=\"rowClass\">\n      <ng-content></ng-content>\n    </teta-table-body>\n  </div>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.TableService }, { type: i0.ElementRef }]; }, propDecorators: { data: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], dict: [{
+                type: Input
+            }], filterOptions: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], cookieName: [{
+                type: Input
+            }], virtual: [{
+                type: Input
+            }], detailComponent: [{
+                type: Input
+            }], activeRow: [{
+                type: Input
+            }], selectedRows: [{
+                type: Input
+            }], selectType: [{
+                type: Input
+            }], aggregate: [{
+                type: Input
+            }], trackRow: [{
+                type: Input
+            }], trackColumns: [{
+                type: Input
+            }], editType: [{
+                type: Input
+            }], editEvent: [{
+                type: Input
+            }], rowEditable: [{
+                type: Input
+            }], rowClass: [{
+                type: Input
+            }], scrollToIndex: [{
+                type: Input
+            }], showHeadCellMenu: [{
+                type: Input
+            }], contextMenu: [{
+                type: Input
+            }], contextMenuOpen: [{
+                type: Input
+            }], contextMenuOpenChange: [{
+                type: Output
+            }], stateChange: [{
+                type: Output
+            }], bodyLeft: [{
+                type: Output
+            }], activeRowChange: [{
+                type: Output
+            }], selectedRowsChange: [{
+                type: Output
+            }], cellClick: [{
+                type: Output
+            }], cellDoubleClick: [{
+                type: Output
+            }], cellFocus: [{
+                type: Output
+            }], cellKeyDown: [{
+                type: Output
+            }], rowLeft: [{
+                type: Output
+            }], rowEditStart: [{
+                type: Output
+            }], rowEditEnd: [{
+                type: Output
+            }], cellEditStart: [{
+                type: Output
+            }], cellEditEnd: [{
+                type: Output
+            }], valueChange: [{
+                type: Output
+            }], tableService: [{
+                type: Output
+            }], menu: [{
+                type: ViewChild,
+                args: ['contextMenu', { static: true }]
+            }], tableClass: [{
+                type: HostBinding,
+                args: ['class.table']
+            }], handleClickOutsideAnyRow: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }], focusIn: [{
+                type: HostListener,
+                args: ['focusin', ['$event']]
+            }], dblclick: [{
+                type: HostListener,
+                args: ['dblclick', ['$event']]
+            }], keydown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }], mousedown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.component.js","sourceRoot":"","sources":["../../../../../src/component/table/table/table.component.ts","../../../../../src/component/table/table/table.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  EventEmitter,\n  HostBinding,\n  HostListener,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  SimpleChanges,\n  TemplateRef,\n  Type,\n  ViewChild,\n} from '@angular/core';\nimport {TableService} from '../service/table.service';\nimport {TableColumn} from '../contract/table-column';\nimport {FilterState} from '../../filter/contarct/filter-state';\nimport {DetailComponentBase} from '../base/detail-component-base';\nimport {ICellEvent} from '../contract/i-cell-event';\nimport {ICellCoordinates} from '../contract/i-cell-coordinates';\nimport {filter, takeWhile} from 'rxjs/operators';\nimport {EditType} from '../enum/edit-type.enum';\nimport {EditEvent} from '../enum/edit-event.enum';\nimport {SelectType} from '../enum/select-type.enum';\nimport {IIdName} from '../../../common/contract/i-id-name';\nimport {IDictionary} from '../../../common/contract/i-dictionary';\nimport {ICellInstance, ICellInstanceEvent} from '../contract/i-cell-instance';\nimport {FilterType} from '../../filter/enum/filter-type.enum';\nimport {VerticalAlign} from '../../../common/enum/vertical-align.enum';\nimport {Align} from '../../../common/enum/align.enum';\n\n@Component({\n  selector: 'teta-table',\n  templateUrl: './table.component.html',\n  styleUrls: ['./table.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [TableService],\n})\nexport class TableComponent<T>\n  implements OnInit, OnDestroy, AfterViewInit, OnChanges {\n  @Input() data: T[] = [];\n  @Input() columns: TableColumn[] = [];\n  @Input() dict: IDictionary<IIdName<any>[]>;\n  @Input() filterOptions: IDictionary<IIdName<any>[]>;\n\n  @Input()\n  set state(state: FilterState) {\n    this._state = state;\n  }\n\n  @Input() cookieName: string;\n  @Input() virtual: boolean;\n  @Input() detailComponent: Type<DetailComponentBase<T>>;\n  @Input() activeRow: T;\n  @Input() selectedRows: T[];\n  @Input() selectType: SelectType = SelectType.mouse;\n  @Input() aggregate: boolean;\n  @Input() trackRow: (index: number, row: T) => any = (index: number, row: T) => {\n    if (row['id']) {\n      return row['id'];\n    }\n    return index;\n  };\n  @Input() trackColumns: (index: number, column: TableColumn) => any = (index: number, column: TableColumn) => {\n    return column.name;\n  };\n  @Input() editType: EditType = EditType.cell;\n  @Input() editEvent: EditEvent = EditEvent.doubleClick;\n  @Input() rowEditable: boolean | ((row: T) => boolean);\n  @Input() rowClass: (row: T, index?: number) => string;\n\n  @Input() set scrollToIndex(index: number) {\n    this._svc.scrollToIndex(index);\n  }\n\n  @Input() showHeadCellMenu = true;\n  @Input() contextMenu: TemplateRef<any>;\n  @Input() contextMenuOpen: boolean;\n  @Output() contextMenuOpenChange = new EventEmitter<boolean>();\n\n  @Output()\n  stateChange: EventEmitter<FilterState> = new EventEmitter<FilterState>();\n  @Output() bodyLeft = new EventEmitter<T>();\n  @Output() activeRowChange: EventEmitter<T> = new EventEmitter();\n  @Output() selectedRowsChange: EventEmitter<T[]> =\n    new EventEmitter();\n  @Output() cellClick = new EventEmitter<ICellInstanceEvent<T>>();\n  @Output() cellDoubleClick = new EventEmitter<ICellInstanceEvent<T>>();\n  @Output() cellFocus = new EventEmitter<ICellInstanceEvent<T>>();\n  @Output() cellKeyDown = new EventEmitter<ICellInstanceEvent<T>>();\n  @Output() rowLeft = new EventEmitter<T>();\n  @Output() rowEditStart = new EventEmitter<ICellInstance<T>>();\n  @Output() rowEditEnd = new EventEmitter<T>();\n  @Output() cellEditStart = new EventEmitter<ICellInstance<T>>();\n  @Output() cellEditEnd = new EventEmitter<ICellInstance<T>>();\n  @Output() valueChange = new EventEmitter<ICellInstance<T>>();\n  @Output() tableService = new EventEmitter<TableService<T>>();\n  @ViewChild('contextMenu', {static: true}) menu: ElementRef;\n  @HostBinding('class.table') private readonly tableClass = true;\n\n  selectedRowsList: T[];\n  contextMenuRow: T;\n  verticalAlign = VerticalAlign;\n  align = Align;\n  private _alive = true;\n  private _headElement: HTMLElement;\n  private _state: FilterState;\n\n  constructor(private _svc: TableService<T>, private _elementRef: ElementRef) {\n    this._svc.state\n      .pipe(\n        takeWhile((_) => this._alive),\n        filter((state) => state !== this._state)\n      )\n      .subscribe((state: FilterState) => this.stateChange.next(state));\n\n    this._svc.editCellStart\n      .pipe(takeWhile((_) => this._alive))\n      .subscribe((item: ICellEvent) => this.cellEditStart.emit(this._svc.getCellInstance(item)));\n\n    this._svc.editCellStop\n      .pipe(takeWhile((_) => this._alive))\n      .subscribe((item: ICellCoordinates) => this.cellEditEnd.emit(this._svc.getCellInstance(item)));\n\n    this._svc.editRowStart\n      .pipe(takeWhile((_) => this._alive))\n      .subscribe((item: ICellEvent) =>\n        this.rowEditStart.emit(this._svc.getCellInstance(item))\n      );\n\n    this._svc.editRowStop\n      .pipe(takeWhile((_) => this._alive))\n      .subscribe((item: ICellCoordinates) =>\n        this.rowEditEnd.emit(this._svc.getRowByIndex(item?.row))\n      );\n\n    this._svc.selectedRows\n      .pipe(takeWhile((_) => this._alive))\n      .subscribe((items: T[]) => {\n        this.selectedRowsList = items;\n        this.selectedRowsChange.emit(items);\n      });\n\n    this._svc.activeRow\n      .pipe(takeWhile((_) => this._alive))\n      .subscribe((item: T) => {\n        this.activeRow = item;\n        this.activeRowChange.emit(item)\n      });\n\n    this._svc.valueChanged\n      .pipe(takeWhile((_) => this._alive))\n      .subscribe((coordinates: ICellCoordinates) => {\n        this.valueChange.emit(this._svc.getCellInstance(coordinates));\n      });\n  }\n\n  @HostListener('document:click', ['$event']) handleClickOutsideAnyRow(\n    event: MouseEvent\n  ) {\n    const coordinates = this.getCoordinates(event);\n    const row = this.getRow(event);\n    const eventIsOnRow = this.eventIsOnRow(event);\n    setTimeout(() => {\n      if (coordinates) {\n        this.cellClick.emit({\n          ...this._svc.getCellInstance(coordinates),\n          event\n        });\n        if (this.editEvent === EditEvent.click) {\n          this.startEditRowOrCell(coordinates);\n        } else {\n          if (this._svc.currentEditCell && (coordinates.row !== this._svc.currentEditCell.row || coordinates.column !== this._svc.currentEditCell.column)) {\n            this.startEditRowOrCell(null);\n          }\n        }\n      }\n      if (row) {\n        if (event.ctrlKey) {\n          this._svc.selectOrDeselectRow(row);\n        } else if (event.shiftKey) {\n          this._svc.selectRange(row);\n        } else {\n          this._svc.selectRows([row]);\n        }\n      }\n      if (!eventIsOnRow && !event.defaultPrevented) {\n        if (this.editType === EditType.row) {\n          this._svc.startEditRow(null);\n        } else {\n          this._svc.startEditCell(null);\n        }\n      }\n    });\n  }\n\n  @HostListener('focusin', ['$event']) focusIn(event: any) {\n    const coordinates = this.getCoordinates(event);\n    if (coordinates) {\n      this.cellFocus.emit({\n        ...this._svc.getCellInstance(coordinates),\n        event\n      });\n      if (this.editEvent === EditEvent.focus) {\n        this.startEditRowOrCell(coordinates);\n      }\n    }\n  }\n\n  @HostListener('dblclick', ['$event'])\n  dblclick(event: MouseEvent) {\n    const coordinates = this.getCoordinates(event);\n    if (coordinates) {\n      setTimeout(() => {\n        this.cellDoubleClick.emit({\n          ...this._svc.getCellInstance(coordinates),\n          event\n        });\n        if (this.editEvent === EditEvent.doubleClick) {\n          this.startEditRowOrCell(coordinates);\n        }\n      });\n    }\n  }\n\n  @HostListener('keydown', ['$event'])\n  keydown(event: KeyboardEvent) {\n    if (event.ctrlKey) {\n      if (event.code === 'KeyA') {\n        event.preventDefault();\n        this._svc.selectAll();\n      }\n      return;\n    }\n    if (event.key === 'Escape') {\n      this._svc.deselectAll();\n      if (this.editType === EditType.row) {\n        this._svc.startEditRow(null);\n      } else {\n        this._svc.startEditCell(null);\n      }\n    }\n    const coordinates = this.getCoordinates(event);\n    if (event.key === 'Enter') {\n      if (this.editType === EditType.row) {\n        this._svc.startEditRow(null);\n      } else {\n        if (this._svc.currentEditCell) {\n          const target = this._svc.getNextRowCell(coordinates);\n          if (target) {\n            this.startEditRowOrCell({\n              row: target.row,\n              column: target.column,\n              event: undefined\n            });\n          } else {\n            this._svc.startEditCell(null);\n          }\n        }\n      }\n    }\n    if (coordinates) {\n      this.cellKeyDown.emit({\n        ...this._svc.getCellInstance(coordinates),\n        event\n      });\n      if (event.key && (event.key.length === 1 || event.key === 'Delete')) {\n        const column = this._svc.getColumnByName(coordinates.column);\n        if (column.filterType !== FilterType.number || isFinite(event.key as any)) {\n          this.startEditRowOrCell({\n            row: coordinates.row,\n            column: coordinates.column,\n            event: event\n          });\n        }\n      }\n      if (event.key === 'Tab' && this._svc.currentEditCell) {\n        event.preventDefault();\n        let target = this._svc.getNextEditableCell(coordinates);\n        if (event.shiftKey) {\n          target = this._svc.getPreviousEditableCell(coordinates);\n        }\n        if (target) {\n          this.startEditRowOrCell({\n            row: target.row,\n            column: target.column,\n            event: undefined\n          });\n        }\n      }\n      if (!this._svc.currentEditCell) {\n        let target;\n        if (event.key === 'ArrowRight') {\n          target = this._svc.getNextCell(coordinates);\n        }\n        if (event.key === 'ArrowLeft') {\n          target = this._svc.getPreviousCell(coordinates);\n        }\n        if (event.key === 'ArrowUp') {\n          target = this._svc.getPreviousRowCell(coordinates);\n        }\n        if (event.key === 'ArrowDown') {\n          target = this._svc.getNextRowCell(coordinates);\n        }\n        if (target) {\n          event.preventDefault();\n          const element = this.getCellElement(target);\n          element?.focus();\n        }\n      }\n    }\n  }\n\n  @HostListener('mousedown', ['$event']) mousedown(event: MouseEvent) {\n    if (event.button === 2) {\n      event.preventDefault();\n    }\n  }\n\n  ngOnInit(): void {\n    this._svc.restoreState();\n    this._svc.restoreHiddenColumns();\n    this.tableService.emit(this._svc);\n  }\n\n  ngAfterViewInit(): void {\n    this._headElement =\n      this._elementRef.nativeElement.querySelector('.table-head');\n  }\n\n  ngOnDestroy(): void {\n    this._alive = false;\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes.hasOwnProperty('editType')) {\n      this._svc.editType = this.editType;\n    }\n    if (changes.hasOwnProperty('selectType')) {\n      this._svc.selectType = this.selectType;\n    }\n    if (changes.hasOwnProperty('selectedRows')) {\n      this._svc.selectRows(this.selectedRows);\n    }\n    if (changes.hasOwnProperty('rowEditable')) {\n      this._svc.rowEditable = this.rowEditable;\n    }\n    if (changes.hasOwnProperty('cookieName')) {\n      this._svc.setCookieName(this.cookieName);\n    }\n    if (changes.hasOwnProperty('columns')) {\n      if (this.columns !== null && this.columns !== undefined) {\n        this._svc.setColumns(this.columns);\n      }\n    }\n    if (changes.hasOwnProperty('data')) {\n      this._svc.setData(this.data);\n      this._svc.selectRows(this.data?.filter((row) => {\n        return this.selectedRows?.some((selectedRow) =>\n          this.trackRow(this._svc.getRowIndex(selectedRow), selectedRow) === this.trackRow(this._svc.getRowIndex(row), row));\n      }));\n    }\n    if (changes.hasOwnProperty('dict')) {\n      this._svc.setDict(this.dict);\n      this._svc.setFilterOptions(this.dict);\n    }\n    if (changes.hasOwnProperty('filterOptions')) {\n      this._svc.setFilterOptions(this.filterOptions);\n    }\n    if (changes.hasOwnProperty('trackRow')) {\n      this._svc.trackRow = this.trackRow;\n    }\n  }\n\n  setContextMenuOpen(value: boolean) {\n    this.contextMenuOpen = value;\n    this.contextMenuOpenChange.emit(this.contextMenuOpen);\n  }\n\n  setContextMenuRow(event: MouseEvent) {\n    this.contextMenuRow = null;\n    const rowElement = this._svc.getEventRow(event);\n    if (rowElement) {\n      const rowIndex = parseInt(rowElement.getAttribute('data-row'), 10);\n      if (rowIndex >= 0) {\n        this.contextMenuRow = this._svc.getRowByIndex(rowIndex);\n      }\n    }\n  }\n\n  private startEditRowOrCell(coordinates: ICellEvent): void {\n    if (this.editType === EditType.row) {\n      this._svc.startEditRow(coordinates);\n    }\n    if (this.editType === EditType.cell) {\n      this._svc.startEditCell(coordinates);\n    }\n  }\n\n  private getCellElement(coordinates: ICellCoordinates): HTMLElement | null {\n    return this._elementRef.nativeElement.querySelector(\n      `teta-cell[data-row=\"${coordinates.row}\"][data-column=\"${coordinates.column}\"]`\n    );\n  }\n\n  private eventIsOnRow(event: Event): boolean {\n    const row = event.composedPath().find((target: HTMLElement) => {\n      return target?.getAttribute && target?.getAttribute('data-row');\n    });\n    return row && this._elementRef.nativeElement.contains(row);\n  }\n\n  private getCoordinates(event: Event): ICellEvent | null {\n    if (event.composedPath().indexOf(this._elementRef.nativeElement) < 0) {\n      return null;\n    }\n    const cell = this._svc.getEventCell(event);\n    if (cell) {\n      const rowIndex = parseInt(cell.getAttribute('data-row'), 10);\n      const columnName = cell.getAttribute('data-column');\n      if (rowIndex >= 0 && columnName) {\n        return {\n          row: rowIndex,\n          column: columnName,\n          event,\n        };\n      }\n    }\n    return null;\n  }\n\n  private getRow(event: Event): T | null {\n    if (event.composedPath().indexOf(this._elementRef.nativeElement) < 0) {\n      return null;\n    }\n    const rowElement = this._svc.getEventRow(event);\n    if (rowElement) {\n      const rowIndex = parseInt(rowElement.getAttribute('data-row'), 10);\n      if (rowIndex >= 0) {\n        return this._svc.getRowByIndex(rowIndex);\n      }\n    }\n    return null;\n  }\n\n  onScroll = (event) => {\n    this._headElement.scrollLeft = event.target.scrollLeft;\n  };\n\n  // private getSelectedText() {\n  //   let text = '';\n  //   if (typeof window.getSelection != 'undefined') {\n  //     text = window.getSelection().toString();\n  //   }\n  //   return text;\n  // }\n}\n","<div class=\"column column_auto\">\n  <teta-table-head\n    style=\"z-index: 1\"\n    [selectType]=\"selectType\"\n    [showHeadCellMenu]=\"showHeadCellMenu\"></teta-table-head>\n  <div class=\"column column_auto position-relative\"\n       style=\"z-index: 0\"\n       [tetaContextMenu]=\"contextMenu\"\n       [verticalAlign]=\"verticalAlign.auto\"\n       [align]=\"align.auto\"\n       [appendToBody]=\"true\"\n       [data]=\"contextMenuRow\"\n       [open]=\"contextMenuOpen\"\n       (openChange)=\"setContextMenuOpen($event)\">\n    <teta-table-body\n      (contextmenu)=\"setContextMenuRow($event)\"\n      (scroll)=\"onScroll($event)\"\n      [aggregate]=\"aggregate\"\n      [virtual]=\"virtual\"\n      [activeRow]=\"activeRow\"\n      [trackRow]=\"trackRow\"\n      [trackColumns]=\"trackColumns\"\n      [selectedRows]=\"selectedRowsList\"\n      [additionalComponent]=\"detailComponent\"\n      [selectType]=\"selectType\"\n      [rowClass]=\"rowClass\">\n      <ng-content></ng-content>\n    </teta-table-body>\n  </div>\n</div>\n"]}