cax-design-system 1.0.0

package/esm2022/table/directives/selectable-row.directive.mjs

@@ -0,0 +1,243 @@
+import { Directive, Input, booleanAttribute, HostListener } from '@angular/core';
+import { DomHandler } from 'cax-design-system/dom';
+import { ObjectUtils } from 'cax-design-system/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../table";
+import * as i2 from "../table.service";
+export class SelectableRow {
+    dt;
+    tableService;
+    el;
+    data;
+    index;
+    caxSelectableRowDisabled;
+    selected;
+    subscription;
+    constructor(dt, tableService, el) {
+        this.dt = dt;
+        this.tableService = tableService;
+        this.el = el;
+        if (this.isEnabled()) {
+            this.subscription = this.dt.tableService.selectionSource$.subscribe(() => {
+                this.selected = this.dt.isSelected(this.data);
+            });
+        }
+    }
+    setRowTabIndex() {
+        if (this.dt.selectionMode === 'single' || this.dt.selectionMode === 'multiple') {
+            return !this.dt.selection ? 0 : this.dt.anchorRowIndex === this.index ? 0 : -1;
+        }
+    }
+    ngOnInit() {
+        if (this.isEnabled()) {
+            this.selected = this.dt.isSelected(this.data);
+        }
+    }
+    onClick(event) {
+        if (this.isEnabled()) {
+            this.dt.handleRowClick({
+                originalEvent: event,
+                rowData: this.data,
+                rowIndex: this.index
+            });
+        }
+    }
+    onTouchEnd(event) {
+        if (this.isEnabled()) {
+            this.dt.handleRowTouchEnd(event);
+        }
+    }
+    onKeyDown(event) {
+        switch (event.code) {
+            case 'ArrowDown':
+                this.onArrowDownKey(event);
+                break;
+            case 'ArrowUp':
+                this.onArrowUpKey(event);
+                break;
+            case 'Home':
+                this.onHomeKey(event);
+                break;
+            case 'End':
+                this.onEndKey(event);
+                break;
+            case 'Space':
+                this.onSpaceKey(event);
+                break;
+            case 'Enter':
+                this.onEnterKey(event);
+                break;
+            default:
+                if (event.code === 'KeyA' && (event.metaKey || event.ctrlKey) && this.dt.selectionMode === 'multiple') {
+                    const data = this.dt.dataToRender(this.dt.processedData);
+                    this.dt.selection = [...data];
+                    this.dt.selectRange(event, data.length - 1, true);
+                    event.preventDefault();
+                }
+                break;
+        }
+    }
+    onArrowDownKey(event) {
+        if (!this.isEnabled()) {
+            return;
+        }
+        const row = event.currentTarget;
+        const nextRow = this.findNextSelectableRow(row);
+        if (nextRow) {
+            nextRow.focus();
+        }
+        event.preventDefault();
+    }
+    onArrowUpKey(event) {
+        if (!this.isEnabled()) {
+            return;
+        }
+        const row = event.currentTarget;
+        const prevRow = this.findPrevSelectableRow(row);
+        if (prevRow) {
+            prevRow.focus();
+        }
+        event.preventDefault();
+    }
+    onEnterKey(event) {
+        if (!this.isEnabled()) {
+            return;
+        }
+        this.dt.handleRowClick({
+            originalEvent: event,
+            rowData: this.data,
+            rowIndex: this.index
+        });
+    }
+    onEndKey(event) {
+        const lastRow = this.findLastSelectableRow();
+        lastRow && this.focusRowChange(this.el.nativeElement, lastRow);
+        if (event.ctrlKey && event.shiftKey) {
+            const data = this.dt.dataToRender(this.dt.rows);
+            const lastSelectableRowIndex = DomHandler.getAttribute(lastRow, 'index');
+            this.dt.anchorRowIndex = lastSelectableRowIndex;
+            this.dt.selection = data.slice(this.index, data.length);
+            this.dt.selectRange(event, this.index);
+        }
+        event.preventDefault();
+    }
+    onHomeKey(event) {
+        const firstRow = this.findFirstSelectableRow();
+        firstRow && this.focusRowChange(this.el.nativeElement, firstRow);
+        if (event.ctrlKey && event.shiftKey) {
+            const data = this.dt.dataToRender(this.dt.rows);
+            const firstSelectableRowIndex = DomHandler.getAttribute(firstRow, 'index');
+            this.dt.anchorRowIndex = this.dt.anchorRowIndex || firstSelectableRowIndex;
+            this.dt.selection = data.slice(0, this.index + 1);
+            this.dt.selectRange(event, this.index);
+        }
+        event.preventDefault();
+    }
+    onSpaceKey(event) {
+        const isInput = event.target instanceof HTMLInputElement || event.target instanceof HTMLSelectElement || event.target instanceof HTMLTextAreaElement;
+        if (isInput) {
+            return;
+        }
+        else {
+            this.onEnterKey(event);
+            if (event.shiftKey && this.dt.selection !== null) {
+                const data = this.dt.dataToRender(this.dt.rows);
+                let index;
+                if (ObjectUtils.isNotEmpty(this.dt.selection) && this.dt.selection.length > 0) {
+                    let firstSelectedRowIndex, lastSelectedRowIndex;
+                    firstSelectedRowIndex = ObjectUtils.findIndexInList(this.dt.selection[0], data);
+                    lastSelectedRowIndex = ObjectUtils.findIndexInList(this.dt.selection[this.dt.selection.length - 1], data);
+                    index = this.index <= firstSelectedRowIndex ? lastSelectedRowIndex : firstSelectedRowIndex;
+                }
+                else {
+                    index = ObjectUtils.findIndexInList(this.dt.selection, data);
+                }
+                this.dt.anchorRowIndex = index;
+                this.dt.selection = index !== this.index ? data.slice(Math.min(index, this.index), Math.max(index, this.index) + 1) : [this.data];
+                this.dt.selectRange(event, this.index);
+            }
+            event.preventDefault();
+        }
+    }
+    focusRowChange(firstFocusableRow, currentFocusedRow) {
+        firstFocusableRow.tabIndex = '-1';
+        currentFocusedRow.tabIndex = '0';
+        DomHandler.focus(currentFocusedRow);
+    }
+    findLastSelectableRow() {
+        const rows = DomHandler.find(this.dt.el.nativeElement, '.cax-selectable-row');
+        return rows ? rows[rows.length - 1] : null;
+    }
+    findFirstSelectableRow() {
+        const firstRow = DomHandler.findSingle(this.dt.el.nativeElement, '.cax-selectable-row');
+        return firstRow;
+    }
+    findNextSelectableRow(row) {
+        let nextRow = row.nextElementSibling;
+        if (nextRow) {
+            if (DomHandler.hasClass(nextRow, 'cax-selectable-row'))
+                return nextRow;
+            else
+                return this.findNextSelectableRow(nextRow);
+        }
+        else {
+            return null;
+        }
+    }
+    findPrevSelectableRow(row) {
+        let prevRow = row.previousElementSibling;
+        if (prevRow) {
+            if (DomHandler.hasClass(prevRow, 'cax-selectable-row'))
+                return prevRow;
+            else
+                return this.findPrevSelectableRow(prevRow);
+        }
+        else {
+            return null;
+        }
+    }
+    isEnabled() {
+        return this.caxSelectableRowDisabled !== true;
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: SelectableRow, deps: [{ token: i1.Table }, { token: i2.TableService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.9", type: SelectableRow, isStandalone: true, selector: "[caxSelectableRow]", inputs: { data: ["caxSelectableRow", "data"], index: ["caxSelectableRowIndex", "index"], caxSelectableRowDisabled: ["caxSelectableRowDisabled", "caxSelectableRowDisabled", booleanAttribute] }, host: { listeners: { "click": "onClick($event)", "touchend": "onTouchEnd($event)", "keydown": "onKeyDown($event)" }, properties: { "class.cax-selectable-row": "isEnabled()", "class.cax-highlight": "selected", "attr.tabindex": "setRowTabIndex()", "attr.data-cax-highlight": "selected", "attr.data-cax-selectable-row": "true" }, classAttribute: "cax-element" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: SelectableRow, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[caxSelectableRow]',
+                    standalone: true,
+                    host: {
+                        class: 'cax-element',
+                        '[class.cax-selectable-row]': 'isEnabled()',
+                        '[class.cax-highlight]': 'selected',
+                        '[attr.tabindex]': 'setRowTabIndex()',
+                        '[attr.data-cax-highlight]': 'selected',
+                        '[attr.data-cax-selectable-row]': 'true'
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i1.Table }, { type: i2.TableService }, { type: i0.ElementRef }], propDecorators: { data: [{
+                type: Input,
+                args: ['caxSelectableRow']
+            }], index: [{
+                type: Input,
+                args: ['caxSelectableRowIndex']
+            }], caxSelectableRowDisabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], onTouchEnd: [{
+                type: HostListener,
+                args: ['touchend', ['$event']]
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selectable-row.directive.js","sourceRoot":"","sources":["../../../../src/app/components/table/directives/selectable-row.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, OnInit, OnDestroy, Input, booleanAttribute, ElementRef, HostListener } from '@angular/core';\nimport { DomHandler } from 'cax-design-system/dom';\nimport { ObjectUtils } from 'cax-design-system/utils';\nimport { Subscription } from 'rxjs';\nimport { Table } from '../table';\nimport { TableService } from '../table.service';\n\n@Directive({\n    selector: '[caxSelectableRow]',\n    standalone: true,\n    host: {\n        class: 'cax-element',\n        '[class.cax-selectable-row]': 'isEnabled()',\n        '[class.cax-highlight]': 'selected',\n        '[attr.tabindex]': 'setRowTabIndex()',\n        '[attr.data-cax-highlight]': 'selected',\n        '[attr.data-cax-selectable-row]': 'true'\n    }\n})\nexport class SelectableRow implements OnInit, OnDestroy {\n    @Input('caxSelectableRow') data: any;\n\n    @Input('caxSelectableRowIndex') index: number | undefined;\n\n    @Input({ transform: booleanAttribute }) caxSelectableRowDisabled: boolean | undefined;\n\n    selected: boolean | undefined;\n\n    subscription: Subscription | undefined;\n\n    constructor(\n        public dt: Table,\n        public tableService: TableService,\n        private el: ElementRef\n    ) {\n        if (this.isEnabled()) {\n            this.subscription = this.dt.tableService.selectionSource$.subscribe(() => {\n                this.selected = this.dt.isSelected(this.data);\n            });\n        }\n    }\n\n    setRowTabIndex() {\n        if (this.dt.selectionMode === 'single' || this.dt.selectionMode === 'multiple') {\n            return !this.dt.selection ? 0 : this.dt.anchorRowIndex === this.index ? 0 : -1;\n        }\n    }\n\n    ngOnInit() {\n        if (this.isEnabled()) {\n            this.selected = this.dt.isSelected(this.data);\n        }\n    }\n\n    @HostListener('click', ['$event'])\n    onClick(event: Event) {\n        if (this.isEnabled()) {\n            this.dt.handleRowClick({\n                originalEvent: event,\n                rowData: this.data,\n                rowIndex: this.index\n            });\n        }\n    }\n\n    @HostListener('touchend', ['$event'])\n    onTouchEnd(event: Event) {\n        if (this.isEnabled()) {\n            this.dt.handleRowTouchEnd(event);\n        }\n    }\n\n    @HostListener('keydown', ['$event'])\n    onKeyDown(event: KeyboardEvent) {\n        switch (event.code) {\n            case 'ArrowDown':\n                this.onArrowDownKey(event);\n                break;\n\n            case 'ArrowUp':\n                this.onArrowUpKey(event);\n                break;\n\n            case 'Home':\n                this.onHomeKey(event);\n                break;\n\n            case 'End':\n                this.onEndKey(event);\n                break;\n\n            case 'Space':\n                this.onSpaceKey(event);\n                break;\n\n            case 'Enter':\n                this.onEnterKey(event);\n                break;\n\n            default:\n                if (event.code === 'KeyA' && (event.metaKey || event.ctrlKey) && this.dt.selectionMode === 'multiple') {\n                    const data = this.dt.dataToRender(this.dt.processedData);\n                    this.dt.selection = [...data];\n                    this.dt.selectRange(event, data.length - 1, true);\n\n                    event.preventDefault();\n                }\n                break;\n        }\n    }\n\n    onArrowDownKey(event: KeyboardEvent) {\n        if (!this.isEnabled()) {\n            return;\n        }\n\n        const row = <HTMLTableRowElement>event.currentTarget;\n        const nextRow = this.findNextSelectableRow(row);\n\n        if (nextRow) {\n            nextRow.focus();\n        }\n\n        event.preventDefault();\n    }\n\n    onArrowUpKey(event: KeyboardEvent) {\n        if (!this.isEnabled()) {\n            return;\n        }\n\n        const row = <HTMLTableRowElement>event.currentTarget;\n        const prevRow = this.findPrevSelectableRow(row);\n\n        if (prevRow) {\n            prevRow.focus();\n        }\n\n        event.preventDefault();\n    }\n\n    onEnterKey(event: KeyboardEvent) {\n        if (!this.isEnabled()) {\n            return;\n        }\n\n        this.dt.handleRowClick({\n            originalEvent: event,\n            rowData: this.data,\n            rowIndex: this.index\n        });\n    }\n\n    onEndKey(event: KeyboardEvent) {\n        const lastRow = this.findLastSelectableRow();\n        lastRow && this.focusRowChange(this.el.nativeElement, lastRow);\n\n        if (event.ctrlKey && event.shiftKey) {\n            const data = this.dt.dataToRender(this.dt.rows);\n            const lastSelectableRowIndex = DomHandler.getAttribute(lastRow, 'index');\n\n            this.dt.anchorRowIndex = lastSelectableRowIndex;\n            this.dt.selection = data.slice(this.index, data.length);\n            this.dt.selectRange(event, this.index);\n        }\n        event.preventDefault();\n    }\n\n    onHomeKey(event: KeyboardEvent) {\n        const firstRow = this.findFirstSelectableRow();\n\n        firstRow && this.focusRowChange(this.el.nativeElement, firstRow);\n\n        if (event.ctrlKey && event.shiftKey) {\n            const data = this.dt.dataToRender(this.dt.rows);\n            const firstSelectableRowIndex = DomHandler.getAttribute(firstRow, 'index');\n\n            this.dt.anchorRowIndex = this.dt.anchorRowIndex || firstSelectableRowIndex;\n            this.dt.selection = data.slice(0, this.index + 1);\n            this.dt.selectRange(event, this.index);\n        }\n        event.preventDefault();\n    }\n\n    onSpaceKey(event) {\n        const isInput = event.target instanceof HTMLInputElement || event.target instanceof HTMLSelectElement || event.target instanceof HTMLTextAreaElement;\n        if (isInput) {\n            return;\n        } else {\n            this.onEnterKey(event);\n\n            if (event.shiftKey && this.dt.selection !== null) {\n                const data = this.dt.dataToRender(this.dt.rows);\n                let index;\n\n                if (ObjectUtils.isNotEmpty(this.dt.selection) && this.dt.selection.length > 0) {\n                    let firstSelectedRowIndex, lastSelectedRowIndex;\n                    firstSelectedRowIndex = ObjectUtils.findIndexInList(this.dt.selection[0], data);\n                    lastSelectedRowIndex = ObjectUtils.findIndexInList(this.dt.selection[this.dt.selection.length - 1], data);\n\n                    index = this.index <= firstSelectedRowIndex ? lastSelectedRowIndex : firstSelectedRowIndex;\n                } else {\n                    index = ObjectUtils.findIndexInList(this.dt.selection, data);\n                }\n\n                this.dt.anchorRowIndex = index;\n                this.dt.selection = index !== this.index ? data.slice(Math.min(index, this.index), Math.max(index, this.index) + 1) : [this.data];\n                this.dt.selectRange(event, this.index);\n            }\n\n            event.preventDefault();\n        }\n    }\n\n    focusRowChange(firstFocusableRow, currentFocusedRow) {\n        firstFocusableRow.tabIndex = '-1';\n        currentFocusedRow.tabIndex = '0';\n        DomHandler.focus(currentFocusedRow);\n    }\n\n    findLastSelectableRow() {\n        const rows = DomHandler.find(this.dt.el.nativeElement, '.cax-selectable-row');\n\n        return rows ? rows[rows.length - 1] : null;\n    }\n\n    findFirstSelectableRow() {\n        const firstRow = DomHandler.findSingle(this.dt.el.nativeElement, '.cax-selectable-row');\n\n        return firstRow;\n    }\n\n    findNextSelectableRow(row: HTMLTableRowElement): HTMLTableRowElement | null {\n        let nextRow = <HTMLTableRowElement>row.nextElementSibling;\n        if (nextRow) {\n            if (DomHandler.hasClass(nextRow, 'cax-selectable-row')) return nextRow;\n            else return this.findNextSelectableRow(nextRow);\n        } else {\n            return null;\n        }\n    }\n\n    findPrevSelectableRow(row: HTMLTableRowElement): HTMLTableRowElement | null {\n        let prevRow = <HTMLTableRowElement>row.previousElementSibling;\n        if (prevRow) {\n            if (DomHandler.hasClass(prevRow, 'cax-selectable-row')) return prevRow;\n            else return this.findPrevSelectableRow(prevRow);\n        } else {\n            return null;\n        }\n    }\n\n    isEnabled() {\n        return this.caxSelectableRowDisabled !== true;\n    }\n\n    ngOnDestroy() {\n        if (this.subscription) {\n            this.subscription.unsubscribe();\n        }\n    }\n}\n"]}

package/esm2022/table/directives/sortable-column.directive.mjs

@@ -0,0 +1,90 @@
+import { Directive, Input, booleanAttribute, HostListener } from '@angular/core';
+import { DomHandler } from 'cax-design-system/dom';
+import * as i0 from "@angular/core";
+import * as i1 from "../table";
+export class SortableColumn {
+    dt;
+    field;
+    caxSortableColumnDisabled;
+    sorted;
+    sortOrder;
+    subscription;
+    constructor(dt) {
+        this.dt = dt;
+        if (this.isEnabled()) {
+            this.subscription = this.dt.tableService.sortSource$.subscribe((sortMeta) => {
+                this.updateSortState();
+            });
+        }
+    }
+    ngOnInit() {
+        if (this.isEnabled()) {
+            this.updateSortState();
+        }
+    }
+    updateSortState() {
+        this.sorted = this.dt.isSorted(this.field);
+        this.sortOrder = this.sorted ? (this.dt.sortOrder === 1 ? 'ascending' : 'descending') : 'none';
+    }
+    onClick(event) {
+        if (this.isEnabled() && !this.isFilterElement(event.target)) {
+            this.updateSortState();
+            this.dt.sort({
+                originalEvent: event,
+                field: this.field
+            });
+            DomHandler.clearSelection();
+        }
+    }
+    onEnterKey(event) {
+        this.onClick(event);
+        event.preventDefault();
+    }
+    isEnabled() {
+        return this.caxSortableColumnDisabled !== true;
+    }
+    isFilterElement(element) {
+        return this.isFilterElementIconOrButton(element) || this.isFilterElementIconOrButton(element?.parentElement?.parentElement);
+    }
+    isFilterElementIconOrButton(element) {
+        return DomHandler.hasClass(element, 'pi-filter-icon') || DomHandler.hasClass(element, 'cax-column-filter-menu-button');
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: SortableColumn, deps: [{ token: i1.Table }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.9", type: SortableColumn, isStandalone: true, selector: "[caxSortableColumn]", inputs: { field: ["caxSortableColumn", "field"], caxSortableColumnDisabled: ["caxSortableColumnDisabled", "caxSortableColumnDisabled", booleanAttribute] }, host: { listeners: { "click": "onClick($event)", "keydown.space": "onEnterKey($event)", "keydown.enter": "onEnterKey($event)" }, properties: { "class.cax-sortable-column": "isEnabled()", "class.cax-highlight": "sorted", "attr.tabindex": "isEnabled() ? \"0\" : null", "attr.role": "\"columnheader\"", "attr.aria-sort": "sortOrder" }, classAttribute: "cax-element" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: SortableColumn, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[caxSortableColumn]',
+                    standalone: true,
+                    host: {
+                        class: 'cax-element',
+                        '[class.cax-sortable-column]': 'isEnabled()',
+                        '[class.cax-highlight]': 'sorted',
+                        '[attr.tabindex]': 'isEnabled() ? "0" : null',
+                        '[attr.role]': '"columnheader"',
+                        '[attr.aria-sort]': 'sortOrder'
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i1.Table }], propDecorators: { field: [{
+                type: Input,
+                args: ['caxSortableColumn']
+            }], caxSortableColumnDisabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], onEnterKey: [{
+                type: HostListener,
+                args: ['keydown.space', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['keydown.enter', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/table/public_api.mjs

@@ -0,0 +1,29 @@
+export * from './table';
+export * from './table.interface';
+export * from './columnfilter.interface';
+export * from './table.module';
+export * from './components/cell-editor/cell-editor';
+export * from './components/column-filter/column-filter';
+export * from './components/column-filter-form-element/column-filter-form-element';
+export * from './components/sort-icon/sort-icon';
+export * from './components/table-body/table-body';
+export * from './components/table-checkbox/table-checkbox';
+export * from './components/table-header-checkbox/table-header-checkbox';
+export * from './components/table-radio-button/table-radio-button';
+export * from './directives/cancel-editable-row.directive';
+export * from './directives/content-menu-row.directive';
+export * from './directives/editable-column.directive';
+export * from './directives/editable-row.directive';
+export * from './directives/frozen-column.directive';
+export * from './directives/init-editable-row.directive';
+export * from './directives/reorderable-column.directive';
+export * from './directives/reorderable-row-handle.directive';
+export * from './directives/reorderable-row.directive';
+export * from './directives/resizable-column.directive';
+export * from './directives/row-group-header.directive';
+export * from './directives/row-toggler.directive';
+export * from './directives/save-editable-row.directive';
+export * from './directives/selectable-row-double-click.directive';
+export * from './directives/selectable-row.directive';
+export * from './directives/sortable-column.directive';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/table/table.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.interface.js","sourceRoot":"","sources":["../../../src/app/components/table/table.interface.ts"],"names":[],"mappings":"","sourcesContent":["import { FilterMetadata, LazyLoadMeta, TableState } from 'cax-design-system/api';\nimport { Table } from './table';\nimport { TemplateRef } from '@angular/core';\n/**\n * Custom select event.\n * @see {@link Table.onRowSelect}\n * @extends {LazyLoadMeta}\n * @group Events\n */\nexport interface TableRowSelectEvent {\n    /**\n     * Browser event.\n     */\n    originalEvent?: Event;\n    /**\n     * Row data.\n     */\n    data?: any;\n    /**\n     * Selection type.\n     */\n    type?: string;\n    /**\n     * Index of the selected row.\n     */\n    index?: number;\n}\n/**\n * Custom unselect event.\n * @see {@link Table.onRowUnselect}\n * @extends {TableRowSelectEvent}\n * @group Events\n */\nexport interface TableRowUnSelectEvent extends TableRowSelectEvent {}\n/**\n * Custom page event.\n * @see {@link Table.onPage}\n */\nexport interface TablePageEvent {\n    /**\n     * Index of the first element.\n     */\n    first: number;\n    /**\n     * Row count.\n     */\n    rows: number;\n}\n/**\n * Custom filter event.\n * @see {@link Table.onFilter}\n * @group Events\n */\nexport interface TableFilterEvent {\n    /**\n     * Filter meta.\n     */\n    filters?: { [s: string]: FilterMetadata | undefined };\n    /**\n     * Value after filter.\n     */\n    filteredValue?: any[] | any;\n}\n/**\n * Custom lazy load event.\n * @see {@link Table.onLazyLoad}\n * @extends {LazyLoadMeta}\n * @group Events\n */\nexport interface TableLazyLoadEvent extends LazyLoadMeta {\n    /**\n     * First element in viewport.\n     */\n    first?: number;\n    /**\n     * Last element in viewport.\n     */\n    last?: number;\n}\n/**\n * Custom row expand event.\n * @see {@link Table.onRowExpand}\n * @group Events\n */\nexport interface TableRowExpandEvent {\n    /**\n     * Browser event.\n     */\n    originalEvent: Event;\n    /**\n     * Row data.\n     */\n    data: any;\n}\n/**\n * Custom row collapse event.\n * @see {@link Table.onRowCollapse}\n * @extends {TableRowExpandEvent}\n * @group Events\n */\nexport interface TableRowCollapseEvent extends TableRowExpandEvent {}\n/**\n * Custom context menu select event.\n * @see {@link Table.onContextMenuSelect}\n * @group Events\n */\nexport interface TableContextMenuSelectEvent {\n    /**\n     * Browser event.\n     */\n    originalEvent: Event;\n    /**\n     * Row data.\n     */\n    data: any;\n    /**\n     * Row index.\n     */\n    index: number;\n}\n/**\n * Custom context menu selection change event.\n * @see {@link Table.contextMenuSelectionChange}\n * @group Events\n */\nexport interface TableContextMenuSelectionChangeEvent {\n    /**\n     * Row data.\n     */\n    data: any;\n}\n/**\n * Custom column resize event.\n * @see {@link Table.onColResize}\n * @group Events\n */\nexport interface TableColResizeEvent {\n    /**\n     * Instance of resized column.\n     */\n    element: HTMLElement;\n    /**\n     * Position.\n     */\n    delta: number;\n}\n/**\n * Custom column reorder event.\n * @see {@link Table.onColReorder}\n * @group Events\n */\nexport interface TableColumnReorderEvent {\n    /**\n     * Index of the dragged item.\n     */\n    dragIndex?: number;\n    /**\n     * Index of the drop position.\n     */\n    dropIndex?: number;\n    /**\n     * Columns after reorder.\n     */\n    columns?: any[];\n}\n/**\n * Custom row reorder event.\n * @see {@link Table.onRowReorder}\n * @group Events\n */\nexport interface TableRowReorderEvent {\n    /**\n     * Index of the dragged item.\n     */\n    dragIndex?: number;\n    /**\n     * Index of the drop position.\n     */\n    dropIndex?: number;\n}\n/**\n * Custom edit event.\n * @group Events\n */\nexport interface TableEditEvent {\n    /**\n     * Field to be edited.\n     */\n    field?: string;\n    /**\n     * New value.\n     */\n    data?: any;\n}\n/**\n * Custom edit init event.\n * @see {@link Table.onEditInit}\n * @group Events\n */\nexport interface TableEditInitEvent extends TableEditEvent {\n    /**\n     * Edited element index.\n     */\n    index: number;\n}\n/**\n * Custom edit cancel event.\n * @see {@link Table.onEditCancel}\n * @group Events\n */\nexport interface TableEditCancelEvent extends TableEditEvent {\n    /**\n     * Browser event.\n     */\n    originalEvent?: Event;\n    /**\n     * Edited element index.\n     */\n    index?: number;\n}\n/**\n * Custom edit complete event.\n * @see {@link Table.onEditComplete}\n * @group Events\n */\nexport interface TableEditCompleteEvent extends TableEditCancelEvent {}\n/**\n * Custom checkbox toggle event.\n * @see {@link Table.onHeaderCheckboxToggle}\n * @group Events\n */\nexport interface TableHeaderCheckboxToggleEvent {\n    /**\n     * Browser event.\n     */\n    originalEvent: Event;\n    /**\n     * Checked state.\n     */\n    checked: boolean;\n}\n/**\n * Custom all selection change event.\n * @see {@link Table.selectAllChange}\n * @group Events\n */\nexport interface TableSelectAllChangeEvent {\n    /**\n     * Browser event.\n     */\n    originalEvent: Event;\n    /**\n     * Checked state.\n     */\n    checked: boolean;\n}\n/**\n * Custom CSV export options.\n */\nexport interface ExportCSVOptions {\n    /**\n     * Boolean value determining whether to export all selected values.\n     */\n    selectionOnly?: boolean;\n    /**\n     * Boolean value determining whether to export all values.\n     */\n    allValues?: boolean;\n}\n/**\n * Defines valid templates in Table.\n * @group Templates\n */\nexport interface TableTemplates {\n    /**\n     * Custom caption template.\n     */\n    caption(): TemplateRef<any>;\n    /**\n     * Custom grouped header template.\n     * @param {Object} context - row data.\n     */\n    headergrouped(context: {\n        /**\n         * Row data.\n         */\n        $implicit?: any;\n        /**\n         * Row index.\n         */\n        rowIndex?: number;\n        /**\n         * Columns.\n         */\n        columns?: any[];\n        /**\n         * Editing state.\n         */\n        editing?: boolean;\n        /**\n         * Frozen state.\n         */\n        frozen?: boolean;\n    }): TemplateRef<any>;\n    /**\n     * Custom grouped header template.\n     * @param {Object} context - header data.\n     */\n    header(context: {\n        /**\n         * Field.\n         */\n        $implicit: string;\n    }): TemplateRef<{ $implicit: string }>;\n    /**\n     * Custom body template.\n     * @param {Object} context - body data.\n     */\n    body(context: {\n        /**\n         * Columns.\n         */\n        $implicit: any;\n        /**\n         * Frozen state.\n         */\n        frozen: boolean;\n    }): TemplateRef<{ $implicit: any; frozen: boolean }>;\n    /**\n     * Custom loading body template.\n     * @param {Object} context - loading body data.\n     */\n    loadingbody(context: {\n        /**\n         * Row span.\n         */\n        rowspan?: number;\n        /**\n         * Row group.\n         */\n        rowgroup?: number;\n    }): TemplateRef<any>;\n    /**\n     * Custom footer template.\n     * @param {Object} context - footer data.\n     */\n    footer(context: {\n        /**\n         * Field.\n         */\n        $implicit: string;\n    }): TemplateRef<{ $implicit: string }>;\n    /**\n     * Custom footer template.\n     * @param {Object} context - footer data.\n     */\n    footergrouped(context: {\n        /**\n         * Columns.\n         */\n        $implicit: any[];\n    }): TemplateRef<any[]>;\n    /**\n     * Custom column group template.\n     * @param {Object} context - columns data.\n     */\n    colgroup(context: {\n        /**\n         * Columns.\n         */\n        $implicit: any[];\n    }): TemplateRef<any[]>;\n    /**\n     * Custom summary template.\n     */\n    summary(): TemplateRef<any>;\n    /**\n     * Custom expanded row template.\n     * @param {Object} context - expanded row data.\n     */\n    rowexpansion(context: {\n        /**\n         * Row span.\n         */\n        rowspan?: number;\n        /**\n         * Row group.\n         */\n        rowgroup?: number;\n        /**\n         * Expanded state.\n         */\n        expanded: boolean;\n    }): TemplateRef<any>;\n    /**\n     * Custom group header template.\n     * @param {Object} context - row data.\n     */\n    groupheader(context: {\n        /**\n         * Row data.\n         */\n        $implicit?: any;\n        /**\n         * Row index.\n         */\n        rowIndex?: number;\n        /**\n         * Columns.\n         */\n        columns?: any[];\n        /**\n         * Editing state.\n         */\n        editing?: boolean;\n        /**\n         * Frozen state.\n         */\n        frozen?: boolean;\n    }): TemplateRef<any>;\n    /**\n     * Custom group footer template.\n     * @param {TableRowContext} context - row data.\n     */\n    groupfooter(context: {\n        /**\n         * Row data.\n         */\n        $implicit?: any;\n        /**\n         * Row index.\n         */\n        rowIndex?: number;\n        /**\n         * Columns.\n         */\n        columns?: any[];\n        /**\n         * Editing state.\n         */\n        editing?: boolean;\n        /**\n         * Frozen state.\n         */\n        frozen?: boolean;\n    }): TemplateRef<any>;\n    /**\n     * Custom frozen header template.\n     * @param {*} context - columns.\n     */\n    frozenheader(): TemplateRef<{ $implicit: any[] }>;\n    /**\n     * Custom frozen body template.\n     * @param {Object} context - row data.\n     */\n    frozenbody(context: {\n        /**\n         * Row data.\n         */\n        $implicit?: any;\n        /**\n         * Row index.\n         */\n        rowIndex?: number;\n        /**\n         * Columns.\n         */\n        columns?: any[];\n        /**\n         * Editing state.\n         */\n        editing?: boolean;\n        /**\n         * Frozen state.\n         */\n        frozen?: boolean;\n    }): TemplateRef<any>;\n    /**\n     * Custom frozen footer template.\n     * @param {*} context - columns.\n     */\n    frozenfooter(): TemplateRef<{ $implicit: any[] }>;\n    /**\n     * Custom frozen column group template.\n     * @param {*} context - columns.\n     */\n    frozencolgroup(): TemplateRef<{ $implicit: any[] }>;\n    /**\n     * Custom frozen expanded row template.\n     * @param {Object} context - row data.\n     */\n    frozenrowexpansion(context: {\n        /**\n         * Row span.\n         */\n        rowspan?: number;\n        /**\n         * Row group.\n         */\n        rowgroup?: number;\n        /**\n         * Expanded state.\n         */\n        expanded: boolean;\n    }): TemplateRef<any>;\n    /**\n     * Custom empty message template.\n     */\n    emptymessage(context: {\n        /**\n         * Columns\n         */\n        $implicit: any[];\n        /**\n         * Frozen state.\n         */\n        frozen: boolean;\n    }): TemplateRef<{ $implicit: any[]; frozen: boolean }>;\n    /**\n     * Custom paginator left template.\n     */\n    paginatorleft(): TemplateRef<any>;\n    /**\n     * Custom paginator right template.\n     */\n    paginatorright(): TemplateRef<any>;\n    /**\n     * Custom paginator dropdown trigger icon template.\n     */\n    paginatordropdownicon(): TemplateRef<any>;\n    /**\n     * Custom paginator dropdown item template.\n     */\n    paginatordropdownitem(): TemplateRef<any>;\n    /**\n     * Custom paginator first page link icon template.\n     */\n    paginatorfirstpagelinkicon(): TemplateRef<any>;\n    /**\n     * Custom paginator last page link icon template.\n     */\n    paginatorlastpagelinkicon(): TemplateRef<any>;\n    /**\n     * Custom paginator previous page link icon template.\n     */\n    paginatorpreviouspagelinkicon(): TemplateRef<any>;\n    /**\n     * Custom paginator next page link icon template.\n     */\n    paginatornextpagelinkicon(): TemplateRef<any>;\n    /**\n     * Custom loading icon template.\n     */\n    loadingicon(): TemplateRef<any>;\n    /**\n     * Custom reorder indicator up icon template.\n     */\n    reorderindicatorupicon(): TemplateRef<any>;\n    /**\n     * Custom reorder indicator down icon template.\n     */\n    reorderindicatordownicon(): TemplateRef<any>;\n    /**\n     * Custom sort icon template.\n     */\n    sorticon(context: {\n        /**\n         * Sort order.\n         */\n        $implicit: number;\n    }): TemplateRef<{ $implicit: number }>;\n    /**\n     * Custom checkbox icon template.\n     * @param {Object} context - checkbox data.\n     */\n    checkboxicon(context: {\n        /**\n         * Checkbox state.\n         */\n        $implicit: boolean;\n        /**\n         * Partial selection state of row node.\n         */\n        partialSelected: boolean;\n    }): TemplateRef<{ $implicit: boolean; partialSelected: boolean }>;\n    /**\n     * Custom header checkbox icon template.\n     * @param {Object} context - checkbox data.\n     */\n    headercheckboxicon(context: {\n        /**\n         * Checked state.\n         */\n        $implicit: boolean;\n    }): TemplateRef<{ $implicit: boolean }>;\n}\n"]}