cps-ui-kit 0.70.0 → 0.72.0

package/esm2020/lib/components/cps-tree-table/directives/cps-tree-table-column-sortable.directive.mjs

@@ -0,0 +1,43 @@
+import { Directive, Input } from '@angular/core';
+import { TTSortableColumn } from 'primeng/treetable';
+import { TreeTableSortIconComponent } from '../tree-table-sort-icon/tree-table-sort-icon.component';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/treetable";
+export class CpsTreeTableColumnSortableDirective extends TTSortableColumn {
+    constructor(elementRef, viewContainerRef, tt) {
+        super(tt);
+        this.elementRef = elementRef;
+        this.viewContainerRef = viewContainerRef;
+        this.tt = tt;
+        this.field = '';
+        this.sortIconRef = this.viewContainerRef.createComponent(TreeTableSortIconComponent);
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.sortIconRef.setInput('field', this.field);
+        this.elementRef.nativeElement.appendChild(this.sortIconRef.location.nativeElement);
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.sortIconRef.destroy();
+        this.viewContainerRef.clear();
+    }
+    onClick(event) {
+        if (!this.elementRef?.nativeElement?.classList?.contains('cps-treetable-col-filter-menu-open')) {
+            super.onClick(event);
+        }
+    }
+}
+CpsTreeTableColumnSortableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CpsTreeTableColumnSortableDirective, deps: [{ token: i0.ElementRef }, { token: i0.ViewContainerRef }, { token: i1.TreeTable }], target: i0.ɵɵFactoryTarget.Directive });
+CpsTreeTableColumnSortableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: CpsTreeTableColumnSortableDirective, isStandalone: true, selector: "[cpsTTColSortable]", inputs: { field: ["cpsTTColSortable", "field"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CpsTreeTableColumnSortableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[cpsTTColSortable]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ViewContainerRef }, { type: i1.TreeTable }]; }, propDecorators: { field: [{
+                type: Input,
+                args: ['cpsTTColSortable']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3BzLXRyZWUtdGFibGUtY29sdW1uLXNvcnRhYmxlLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nwcy11aS1raXQvc3JjL2xpYi9jb21wb25lbnRzL2Nwcy10cmVlLXRhYmxlL2RpcmVjdGl2ZXMvY3BzLXRyZWUtdGFibGUtY29sdW1uLXNvcnRhYmxlLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBRUwsU0FBUyxFQUVULEtBQUssRUFJTixNQUFNLGVBQWUsQ0FBQztBQUN2QixPQUFPLEVBQUUsZ0JBQWdCLEVBQWEsTUFBTSxtQkFBbUIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSx3REFBd0QsQ0FBQzs7O0FBTXBHLE1BQU0sT0FBTyxtQ0FDWCxTQUFRLGdCQUFnQjtJQU14QixZQUNVLFVBQXNCLEVBQ3RCLGdCQUFrQyxFQUMxQixFQUFhO1FBRTdCLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUpGLGVBQVUsR0FBVixVQUFVLENBQVk7UUFDdEIscUJBQWdCLEdBQWhCLGdCQUFnQixDQUFrQjtRQUMxQixPQUFFLEdBQUYsRUFBRSxDQUFXO1FBTkssVUFBSyxHQUFHLEVBQUUsQ0FBQztRQVM3QyxJQUFJLENBQUMsV0FBVyxHQUFHLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxlQUFlLENBQ3RELDBCQUEwQixDQUMzQixDQUFDO0lBQ0osQ0FBQztJQUVRLFFBQVE7UUFDZixLQUFLLENBQUMsUUFBUSxFQUFFLENBQUM7UUFDakIsSUFBSSxDQUFDLFdBQVcsQ0FBQyxRQUFRLENBQUMsT0FBTyxFQUFFLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUMvQyxJQUFJLENBQUMsVUFBVSxDQUFDLGFBQWEsQ0FBQyxXQUFXLENBQ3ZDLElBQUksQ0FBQyxXQUFXLENBQUMsUUFBUSxDQUFDLGFBQWEsQ0FDeEMsQ0FBQztJQUNKLENBQUM7SUFFUSxXQUFXO1FBQ2xCLEtBQUssQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUNwQixJQUFJLENBQUMsV0FBVyxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQzNCLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUNoQyxDQUFDO0lBRVEsT0FBTyxDQUFDLEtBQWlCO1FBQ2hDLElBQ0UsQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLGFBQWEsRUFBRSxTQUFTLEVBQUUsUUFBUSxDQUNsRCxvQ0FBb0MsQ0FDckMsRUFDRDtZQUNBLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7U0FDdEI7SUFDSCxDQUFDOztnSUF4Q1UsbUNBQW1DO29IQUFuQyxtQ0FBbUM7MkZBQW5DLG1DQUFtQztrQkFKL0MsU0FBUzttQkFBQztvQkFDVCxVQUFVLEVBQUUsSUFBSTtvQkFDaEIsUUFBUSxFQUFFLG9CQUFvQjtpQkFDL0I7d0pBS3FDLEtBQUs7c0JBQXhDLEtBQUs7dUJBQUMsa0JBQWtCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgQ29tcG9uZW50UmVmLFxuICBEaXJlY3RpdmUsXG4gIEVsZW1lbnRSZWYsXG4gIElucHV0LFxuICBPbkRlc3Ryb3ksXG4gIE9uSW5pdCxcbiAgVmlld0NvbnRhaW5lclJlZlxufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFRUU29ydGFibGVDb2x1bW4sIFRyZWVUYWJsZSB9IGZyb20gJ3ByaW1lbmcvdHJlZXRhYmxlJztcbmltcG9ydCB7IFRyZWVUYWJsZVNvcnRJY29uQ29tcG9uZW50IH0gZnJvbSAnLi4vdHJlZS10YWJsZS1zb3J0LWljb24vdHJlZS10YWJsZS1zb3J0LWljb24uY29tcG9uZW50JztcblxuQERpcmVjdGl2ZSh7XG4gIHN0YW5kYWxvbmU6IHRydWUsXG4gIHNlbGVjdG9yOiAnW2Nwc1RUQ29sU29ydGFibGVdJ1xufSlcbmV4cG9ydCBjbGFzcyBDcHNUcmVlVGFibGVDb2x1bW5Tb3J0YWJsZURpcmVjdGl2ZVxuICBleHRlbmRzIFRUU29ydGFibGVDb2x1bW5cbiAgaW1wbGVtZW50cyBPbkluaXQsIE9uRGVzdHJveVxue1xuICBASW5wdXQoJ2Nwc1RUQ29sU29ydGFibGUnKSBvdmVycmlkZSBmaWVsZCA9ICcnO1xuICBzb3J0SWNvblJlZjogQ29tcG9uZW50UmVmPFRyZWVUYWJsZVNvcnRJY29uQ29tcG9uZW50PjtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBwcml2YXRlIGVsZW1lbnRSZWY6IEVsZW1lbnRSZWYsXG4gICAgcHJpdmF0ZSB2aWV3Q29udGFpbmVyUmVmOiBWaWV3Q29udGFpbmVyUmVmLFxuICAgIHB1YmxpYyBvdmVycmlkZSB0dDogVHJlZVRhYmxlXG4gICkge1xuICAgIHN1cGVyKHR0KTtcbiAgICB0aGlzLnNvcnRJY29uUmVmID0gdGhpcy52aWV3Q29udGFpbmVyUmVmLmNyZWF0ZUNvbXBvbmVudChcbiAgICAgIFRyZWVUYWJsZVNvcnRJY29uQ29tcG9uZW50XG4gICAgKTtcbiAgfVxuXG4gIG92ZXJyaWRlIG5nT25Jbml0KCk6IHZvaWQge1xuICAgIHN1cGVyLm5nT25Jbml0KCk7XG4gICAgdGhpcy5zb3J0SWNvblJlZi5zZXRJbnB1dCgnZmllbGQnLCB0aGlzLmZpZWxkKTtcbiAgICB0aGlzLmVsZW1lbnRSZWYubmF0aXZlRWxlbWVudC5hcHBlbmRDaGlsZChcbiAgICAgIHRoaXMuc29ydEljb25SZWYubG9jYXRpb24ubmF0aXZlRWxlbWVudFxuICAgICk7XG4gIH1cblxuICBvdmVycmlkZSBuZ09uRGVzdHJveSgpOiB2b2lkIHtcbiAgICBzdXBlci5uZ09uRGVzdHJveSgpO1xuICAgIHRoaXMuc29ydEljb25SZWYuZGVzdHJveSgpO1xuICAgIHRoaXMudmlld0NvbnRhaW5lclJlZi5jbGVhcigpO1xuICB9XG5cbiAgb3ZlcnJpZGUgb25DbGljayhldmVudDogTW91c2VFdmVudCk6IHZvaWQge1xuICAgIGlmIChcbiAgICAgICF0aGlzLmVsZW1lbnRSZWY/Lm5hdGl2ZUVsZW1lbnQ/LmNsYXNzTGlzdD8uY29udGFpbnMoXG4gICAgICAgICdjcHMtdHJlZXRhYmxlLWNvbC1maWx0ZXItbWVudS1vcGVuJ1xuICAgICAgKVxuICAgICkge1xuICAgICAgc3VwZXIub25DbGljayhldmVudCk7XG4gICAgfVxuICB9XG59XG4iXX0=

package/esm2020/lib/components/cps-tree-table/directives/cps-tree-table-header-selectable.directive.mjs

@@ -0,0 +1,28 @@
+import { Directive } from '@angular/core';
+import { TTHeaderCheckbox } from 'primeng/treetable';
+import * as i0 from "@angular/core";
+export class CpsTreeTableHeaderSelectableDirective {
+    constructor(elementRef, viewContainerRef) {
+        this.elementRef = elementRef;
+        this.viewContainerRef = viewContainerRef;
+        this.checkboxCompRef =
+            this.viewContainerRef.createComponent(TTHeaderCheckbox);
+    }
+    ngOnInit() {
+        this.elementRef.nativeElement.appendChild(this.checkboxCompRef.location.nativeElement);
+    }
+    ngOnDestroy() {
+        this.checkboxCompRef.destroy();
+        this.viewContainerRef.clear();
+    }
+}
+CpsTreeTableHeaderSelectableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CpsTreeTableHeaderSelectableDirective, deps: [{ token: i0.ElementRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+CpsTreeTableHeaderSelectableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: CpsTreeTableHeaderSelectableDirective, isStandalone: true, selector: "[cpsTTHdrSelectable]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CpsTreeTableHeaderSelectableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[cpsTTHdrSelectable]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ViewContainerRef }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/cps-tree-table/directives/cps-tree-table-row-toggler.directive.mjs

@@ -0,0 +1,32 @@
+import { Directive, Input } from '@angular/core';
+import { TreeTableToggler } from 'primeng/treetable';
+import * as i0 from "@angular/core";
+export class CpsTreetableRowTogglerDirective {
+    constructor(elementRef, viewContainerRef) {
+        this.elementRef = elementRef;
+        this.viewContainerRef = viewContainerRef;
+        this.togglerCompRef =
+            this.viewContainerRef.createComponent(TreeTableToggler);
+    }
+    ngOnInit() {
+        this.togglerCompRef.setInput('rowNode', this.rowNode);
+        this.elementRef.nativeElement.prepend(this.togglerCompRef.location.nativeElement);
+    }
+    ngOnDestroy() {
+        this.togglerCompRef.destroy();
+        this.viewContainerRef.clear();
+    }
+}
+CpsTreetableRowTogglerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CpsTreetableRowTogglerDirective, deps: [{ token: i0.ElementRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+CpsTreetableRowTogglerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: CpsTreetableRowTogglerDirective, isStandalone: true, selector: "[cpsTTRowToggler]", inputs: { rowNode: ["cpsTTRowToggler", "rowNode"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CpsTreetableRowTogglerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[cpsTTRowToggler]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ViewContainerRef }]; }, propDecorators: { rowNode: [{
+                type: Input,
+                args: ['cpsTTRowToggler']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/cps-tree-table/directives/internal/tree-table-unsort.directive.mjs

@@ -0,0 +1,157 @@
+import { Directive, Host, Self, Optional } from '@angular/core';
+import { ObjectUtils } from 'primeng/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/treetable";
+export class TreeTableUnsortDirective {
+    constructor(pTreeTable) {
+        this.pTreeTable = pTreeTable;
+        this.defaultSortOrderInitialized = false;
+        pTreeTable.tableService.uiUpdateSource$.subscribe((val) => {
+            if (val != null && val.length > 0 && !this.defaultSortOrderInitialized) {
+                let i = 0;
+                val.forEach((v) => {
+                    v._defaultSortOrder = i++;
+                });
+                this.defaultSortOrderInitialized = true;
+            }
+        });
+        pTreeTable.sort = (event) => {
+            if (pTreeTable.sortMode === 'single') {
+                if (pTreeTable.sortField === event.field &&
+                    pTreeTable.sortOrder === -1) {
+                    event.field = '_defaultSortOrder';
+                }
+                pTreeTable._sortOrder =
+                    pTreeTable.sortField === event.field
+                        ? pTreeTable.sortOrder * -1
+                        : pTreeTable.defaultSortOrder;
+                pTreeTable._sortField = event.field;
+                pTreeTable.sortSingle();
+            }
+            if (pTreeTable.sortMode === 'multiple') {
+                let resetIndex = false;
+                const sortMeta = pTreeTable.getSortMeta(event.field);
+                if (sortMeta) {
+                    for (let i = 0; i < pTreeTable._multiSortMeta.length; i++) {
+                        if (pTreeTable._multiSortMeta[i].field === sortMeta.field) {
+                            pTreeTable._multiSortMeta.splice(i, 1);
+                        }
+                    }
+                    if (sortMeta.order === 1) {
+                        sortMeta.order = sortMeta.order * -1;
+                        pTreeTable.multiSortMeta.push(sortMeta);
+                    }
+                    if (pTreeTable._multiSortMeta?.length === 0) {
+                        pTreeTable.multiSortMeta.push({
+                            field: '_defaultSortOrder',
+                            order: pTreeTable.defaultSortOrder
+                        });
+                        resetIndex = true;
+                    }
+                }
+                else {
+                    if (!pTreeTable.multiSortMeta) {
+                        pTreeTable._multiSortMeta = [];
+                    }
+                    pTreeTable.multiSortMeta.push({
+                        field: event.field,
+                        order: pTreeTable.defaultSortOrder
+                    });
+                }
+                pTreeTable.sortMultiple();
+                if (resetIndex)
+                    pTreeTable._multiSortMeta = [];
+            }
+        };
+        pTreeTable.sortNodes = (nodes) => {
+            if (!nodes || nodes.length === 0) {
+                return;
+            }
+            if (pTreeTable.customSort) {
+                pTreeTable.sortFunction.emit({
+                    data: nodes,
+                    mode: pTreeTable.sortMode,
+                    field: pTreeTable.sortField,
+                    order: pTreeTable.sortOrder
+                });
+            }
+            else {
+                const isUnsort = pTreeTable.sortField === '_defaultSortOrder';
+                nodes.sort((node1, node2) => {
+                    const value1 = isUnsort
+                        ? node1._defaultSortOrder
+                        : ObjectUtils.resolveFieldData(node1.data, pTreeTable.sortField);
+                    const value2 = isUnsort
+                        ? node2._defaultSortOrder
+                        : ObjectUtils.resolveFieldData(node2.data, pTreeTable.sortField);
+                    let result = null;
+                    if (value1 == null && value2 != null)
+                        result = -1;
+                    else if (value1 != null && value2 == null)
+                        result = 1;
+                    else if (value1 == null && value2 == null)
+                        result = 0;
+                    else if (typeof value1 === 'string' && typeof value2 === 'string')
+                        result = value1.localeCompare(value2, undefined, { numeric: true });
+                    else
+                        result = value1 < value2 ? -1 : value1 > value2 ? 1 : 0;
+                    return pTreeTable.sortOrder * result;
+                });
+            }
+            for (const node of nodes) {
+                pTreeTable.sortNodes(node.children);
+            }
+        };
+        pTreeTable.multisortField = (node1, node2, multiSortMeta, index) => {
+            if (ObjectUtils.isEmpty(pTreeTable.multiSortMeta) ||
+                ObjectUtils.isEmpty(multiSortMeta[index])) {
+                return 0;
+            }
+            const isUnsort = multiSortMeta[index].field === '_defaultSortOrder';
+            const value1 = isUnsort
+                ? node1._defaultSortOrder
+                : ObjectUtils.resolveFieldData(node1.data, multiSortMeta[index].field);
+            const value2 = isUnsort
+                ? node2._defaultSortOrder
+                : ObjectUtils.resolveFieldData(node2.data, multiSortMeta[index].field);
+            let result = 0;
+            if (value1 == null && value2 != null)
+                result = -1;
+            else if (value1 != null && value2 == null)
+                result = 1;
+            else if (value1 == null && value2 == null)
+                result = 0;
+            if (typeof value1 === 'string' || value1 instanceof String) {
+                if (value1.localeCompare && value1 !== value2) {
+                    return (multiSortMeta[index].order *
+                        value1.localeCompare(value2, undefined, { numeric: true }));
+                }
+            }
+            else {
+                result = value1 < value2 ? -1 : 1;
+            }
+            if (value1 === value2) {
+                return multiSortMeta.length - 1 > index
+                    ? pTreeTable.multisortField(node1, node2, multiSortMeta, index + 1)
+                    : 0;
+            }
+            return multiSortMeta[index].order * result;
+        };
+    }
+}
+TreeTableUnsortDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeTableUnsortDirective, deps: [{ token: i1.TreeTable, host: true, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });
+TreeTableUnsortDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: TreeTableUnsortDirective, isStandalone: true, selector: "[ttWithUnsort]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeTableUnsortDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[ttWithUnsort]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TreeTable, decorators: [{
+                    type: Host
+                }, {
+                    type: Self
+                }, {
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-table-unsort.directive.js","sourceRoot":"","sources":["../../../../../../../../projects/cps-ui-kit/src/lib/components/cps-tree-table/directives/internal/tree-table-unsort.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Host, Self, Optional } from '@angular/core';\nimport { TreeTable } from 'primeng/treetable';\nimport { ObjectUtils } from 'primeng/utils';\n\n@Directive({\n  standalone: true,\n  selector: '[ttWithUnsort]'\n})\nexport class TreeTableUnsortDirective {\n  defaultSortOrderInitialized = false;\n\n  constructor(@Host() @Self() @Optional() public pTreeTable: TreeTable) {\n    pTreeTable.tableService.uiUpdateSource$.subscribe((val: any[]) => {\n      if (val != null && val.length > 0 && !this.defaultSortOrderInitialized) {\n        let i = 0;\n        val.forEach((v) => {\n          v._defaultSortOrder = i++;\n        });\n        this.defaultSortOrderInitialized = true;\n      }\n    });\n\n    pTreeTable.sort = (event: any) => {\n      if (pTreeTable.sortMode === 'single') {\n        if (\n          pTreeTable.sortField === event.field &&\n          pTreeTable.sortOrder === -1\n        ) {\n          event.field = '_defaultSortOrder';\n        }\n\n        pTreeTable._sortOrder =\n          pTreeTable.sortField === event.field\n            ? pTreeTable.sortOrder * -1\n            : pTreeTable.defaultSortOrder;\n        pTreeTable._sortField = event.field;\n        pTreeTable.sortSingle();\n      }\n      if (pTreeTable.sortMode === 'multiple') {\n        let resetIndex = false;\n        const sortMeta = pTreeTable.getSortMeta(event.field);\n\n        if (sortMeta) {\n          for (let i = 0; i < pTreeTable._multiSortMeta.length; i++) {\n            if (pTreeTable._multiSortMeta[i].field === sortMeta.field) {\n              pTreeTable._multiSortMeta.splice(i, 1);\n            }\n          }\n          if (sortMeta.order === 1) {\n            sortMeta.order = sortMeta.order * -1;\n            pTreeTable.multiSortMeta.push(sortMeta);\n          }\n          if (pTreeTable._multiSortMeta?.length === 0) {\n            pTreeTable.multiSortMeta.push({\n              field: '_defaultSortOrder',\n              order: pTreeTable.defaultSortOrder\n            });\n            resetIndex = true;\n          }\n        } else {\n          if (!pTreeTable.multiSortMeta) {\n            pTreeTable._multiSortMeta = [];\n          }\n          pTreeTable.multiSortMeta.push({\n            field: event.field,\n            order: pTreeTable.defaultSortOrder\n          });\n        }\n\n        pTreeTable.sortMultiple();\n        if (resetIndex) pTreeTable._multiSortMeta = [];\n      }\n    };\n\n    pTreeTable.sortNodes = (nodes) => {\n      if (!nodes || nodes.length === 0) {\n        return;\n      }\n\n      if (pTreeTable.customSort) {\n        pTreeTable.sortFunction.emit({\n          data: nodes,\n          mode: pTreeTable.sortMode,\n          field: pTreeTable.sortField,\n          order: pTreeTable.sortOrder\n        });\n      } else {\n        const isUnsort = pTreeTable.sortField === '_defaultSortOrder';\n        nodes.sort((node1: any, node2: any) => {\n          const value1 = isUnsort\n            ? node1._defaultSortOrder\n            : ObjectUtils.resolveFieldData(node1.data, pTreeTable.sortField);\n          const value2 = isUnsort\n            ? node2._defaultSortOrder\n            : ObjectUtils.resolveFieldData(node2.data, pTreeTable.sortField);\n          let result = null;\n\n          if (value1 == null && value2 != null) result = -1;\n          else if (value1 != null && value2 == null) result = 1;\n          else if (value1 == null && value2 == null) result = 0;\n          else if (typeof value1 === 'string' && typeof value2 === 'string')\n            result = value1.localeCompare(value2, undefined, { numeric: true });\n          else result = value1 < value2 ? -1 : value1 > value2 ? 1 : 0;\n\n          return pTreeTable.sortOrder * result;\n        });\n      }\n\n      for (const node of nodes) {\n        pTreeTable.sortNodes(node.children);\n      }\n    };\n\n    pTreeTable.multisortField = (node1, node2, multiSortMeta, index) => {\n      if (\n        ObjectUtils.isEmpty(pTreeTable.multiSortMeta) ||\n        ObjectUtils.isEmpty(multiSortMeta[index])\n      ) {\n        return 0;\n      }\n      const isUnsort = multiSortMeta[index].field === '_defaultSortOrder';\n      const value1 = isUnsort\n        ? node1._defaultSortOrder\n        : ObjectUtils.resolveFieldData(node1.data, multiSortMeta[index].field);\n      const value2 = isUnsort\n        ? node2._defaultSortOrder\n        : ObjectUtils.resolveFieldData(node2.data, multiSortMeta[index].field);\n      let result = 0;\n\n      if (value1 == null && value2 != null) result = -1;\n      else if (value1 != null && value2 == null) result = 1;\n      else if (value1 == null && value2 == null) result = 0;\n      if (typeof value1 === 'string' || value1 instanceof String) {\n        if (value1.localeCompare && value1 !== value2) {\n          return (\n            multiSortMeta[index].order *\n            value1.localeCompare(value2, undefined, { numeric: true })\n          );\n        }\n      } else {\n        result = value1 < value2 ? -1 : 1;\n      }\n\n      if (value1 === value2) {\n        return multiSortMeta.length - 1 > index\n          ? pTreeTable.multisortField(node1, node2, multiSortMeta, index + 1)\n          : 0;\n      }\n\n      return multiSortMeta[index].order * result;\n    };\n  }\n}\n"]}

package/esm2020/lib/components/cps-tree-table/tree-table-sort-icon/tree-table-sort-icon.component.mjs

@@ -0,0 +1,73 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, Input, ViewEncapsulation } from '@angular/core';
+import { SortAltIcon } from 'primeng/icons/sortalt';
+import { SortAmountDownIcon } from 'primeng/icons/sortamountdown';
+import { SortAmountUpAltIcon } from 'primeng/icons/sortamountupalt';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/treetable";
+import * as i2 from "@angular/common";
+export class TreeTableSortIconComponent {
+    constructor(tt, cd) {
+        this.tt = tt;
+        this.cd = cd;
+        this.field = '';
+        this.sortOrder = 0;
+        this.subscription = this.tt.tableService.sortSource$.subscribe((sortMeta) => {
+            this.updateSortState();
+            this.cd.markForCheck();
+        });
+    }
+    ngOnInit() {
+        this.updateSortState();
+    }
+    onClick(event) {
+        event.preventDefault();
+    }
+    updateSortState() {
+        if (this.tt.sortMode === 'single') {
+            this.sortOrder = this.tt.isSorted(this.field) ? this.tt.sortOrder : 0;
+        }
+        else if (this.tt.sortMode === 'multiple') {
+            const sortMeta = this.tt.getSortMeta(this.field);
+            this.sortOrder = sortMeta ? sortMeta.order : 0;
+        }
+    }
+    getMultiSortMetaIndex() {
+        const multiSortMeta = this.tt._multiSortMeta;
+        let index = -1;
+        if (multiSortMeta &&
+            this.tt.sortMode === 'multiple' &&
+            multiSortMeta.length > 1) {
+            for (let i = 0; i < multiSortMeta.length; i++) {
+                const meta = multiSortMeta[i];
+                if (meta.field === this.field || meta.field === this.field) {
+                    index = i;
+                    break;
+                }
+            }
+        }
+        return index;
+    }
+    getBadgeValue() {
+        return this.getMultiSortMetaIndex() + 1;
+    }
+    isMultiSorted() {
+        return this.tt.sortMode === 'multiple' && this.getMultiSortMetaIndex() > -1;
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+}
+TreeTableSortIconComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeTableSortIconComponent, deps: [{ token: i1.TreeTable }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+TreeTableSortIconComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: TreeTableSortIconComponent, isStandalone: true, selector: "tree-table-sort-icon", inputs: { field: "field" }, host: { classAttribute: "p-element" }, ngImport: i0, template: "<ng-container *ngIf=\"!tt.sortIconTemplate\">\n  <SortAltIcon\n    [styleClass]=\"'p-sortable-column-icon'\"\n    *ngIf=\"sortOrder === 0\" />\n  <SortAmountUpAltIcon\n    [styleClass]=\"'p-sortable-column-icon'\"\n    *ngIf=\"sortOrder === 1\" />\n  <SortAmountDownIcon\n    [styleClass]=\"'p-sortable-column-icon'\"\n    *ngIf=\"sortOrder === -1\" />\n</ng-container>\n<span *ngIf=\"tt.sortIconTemplate\" class=\"p-sortable-column-icon\">\n  <ng-template\n    *ngTemplateOutlet=\"\n      tt.sortIconTemplate;\n      context: { $implicit: sortOrder }\n    \"></ng-template>\n</span>\n<span *ngIf=\"isMultiSorted()\" class=\"p-sortable-column-badge\">{{\n  getBadgeValue()\n}}</span>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: SortAltIcon, selector: "SortAltIcon" }, { kind: "component", type: SortAmountUpAltIcon, selector: "SortAmountUpAltIcon" }, { kind: "component", type: SortAmountDownIcon, selector: "SortAmountDownIcon" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TreeTableSortIconComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tree-table-sort-icon', standalone: true, imports: [CommonModule, SortAltIcon, SortAmountUpAltIcon, SortAmountDownIcon], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        class: 'p-element'
+                    }, template: "<ng-container *ngIf=\"!tt.sortIconTemplate\">\n  <SortAltIcon\n    [styleClass]=\"'p-sortable-column-icon'\"\n    *ngIf=\"sortOrder === 0\" />\n  <SortAmountUpAltIcon\n    [styleClass]=\"'p-sortable-column-icon'\"\n    *ngIf=\"sortOrder === 1\" />\n  <SortAmountDownIcon\n    [styleClass]=\"'p-sortable-column-icon'\"\n    *ngIf=\"sortOrder === -1\" />\n</ng-container>\n<span *ngIf=\"tt.sortIconTemplate\" class=\"p-sortable-column-icon\">\n  <ng-template\n    *ngTemplateOutlet=\"\n      tt.sortIconTemplate;\n      context: { $implicit: sortOrder }\n    \"></ng-template>\n</span>\n<span *ngIf=\"isMultiSorted()\" class=\"p-sortable-column-badge\">{{\n  getBadgeValue()\n}}</span>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.TreeTable }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { field: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/public-api.mjs

@@ -16,6 +16,10 @@ export * from './lib/components/cps-table/cps-table.component';
 export * from './lib/components/cps-table/directives/cps-table-column-sortable.directive';
 export * from './lib/components/cps-table/directives/cps-table-column-filter.directive';
 export * from './lib/components/cps-table/directives/cps-table-header-selectable.directive';
+export * from './lib/components/cps-tree-table/cps-tree-table.component';
+export * from './lib/components/cps-tree-table/directives/cps-tree-table-column-sortable.directive';
+export * from './lib/components/cps-tree-table/directives/cps-tree-table-row-toggler.directive';
+export * from './lib/components/cps-tree-table/directives/cps-tree-table-header-selectable.directive';
 export * from './lib/components/cps-tag/cps-tag.component';
 export * from './lib/components/cps-chip/cps-chip.component';
 export * from './lib/components/cps-menu/cps-menu.component';
@@ -33,4 +37,4 @@ export * from './lib/components/cps-tab-group/cps-tab-group.component';
 export * from './lib/components/cps-tab-group/cps-tab/cps-tab.component';
 export * from './lib/directives/cps-tooltip.directive';
 export * from './lib/utils/colors-utils';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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