@quadrel-enterprise-ui/framework 1.0.0 → 18.19.1

package/esm2022/lib/tree/row/tree-row.component.mjs

@@ -0,0 +1,85 @@
+// @ts-strict-ignore
+import { Component, Input, ViewEncapsulation } from '@angular/core';
+import { QdDataFacetsContextService } from '../../core/data-facets/data-facets-context.service';
+import { COMPONENT_MAP } from '../../core/data-facets/data-facets.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/data-facets/data-facets-context.service";
+import * as i2 from "@angular/common";
+import * as i3 from "../../icon/icon/icon.component";
+import * as i4 from "./actions/secondary/menu/tree-row-actions-secondary-menu.component";
+export class QdTreeRowComponent {
+    contextService;
+    columnsDetails;
+    indentation = 0;
+    config;
+    testId;
+    set rowData(data) {
+        this._rowData = data;
+        this.contextService.setContext(data);
+        this.expanded = data.expanded ?? false;
+    }
+    get rowData() {
+        return this._rowData;
+    }
+    set rowIndex(index) {
+        this._rowIndex = index;
+        this.contextService.setContext({ index });
+    }
+    get rowIndex() {
+        return this._rowIndex;
+    }
+    expanded = false;
+    _rowData;
+    _rowIndex;
+    constructor(contextService) {
+        this.contextService = contextService;
+    }
+    onExpanderClick() {
+        this.expanded = !this.expanded;
+    }
+    getCellClass(column) {
+        let className = '';
+        if (column.isMainColumn)
+            className += ' main-column';
+        if (column.isLastColumn)
+            className += ' last-column';
+        return className;
+    }
+    getComponentType(item) {
+        return COMPONENT_MAP[item.type];
+    }
+    getComponentInputs(item) {
+        const i18n = item.i18n;
+        const config = item.options;
+        const data = this.rowData[item.column];
+        const testId = this.testId + '-cell-' + item.index;
+        const isTranslated = item.options && item.options.isTranslated !== undefined;
+        return {
+            ...(data && { data }),
+            ...(config && { config }),
+            ...(i18n && isTranslated && { i18n }),
+            ...(testId && { testId })
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTreeRowComponent, deps: [{ token: i1.QdDataFacetsContextService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdTreeRowComponent, selector: "[qd-tree-row]", inputs: { columnsDetails: "columnsDetails", indentation: "indentation", config: "config", testId: ["data-test-id", "testId"], rowData: "rowData", rowIndex: "rowIndex" }, providers: [QdDataFacetsContextService], ngImport: i0, template: "<ng-container *ngFor=\"let column of columnsDetails\">\n  <ng-container [ngSwitch]=\"column.type\">\n    <ng-container *ngSwitchCase=\"'group'\">\n      <td\n        (click)=\"onExpanderClick()\"\n        [class]=\"\n          [\n            'qd-tree-body-cell',\n            'qd-tree-body-cell-group',\n            'qd-tree-body-cell-group-index-' + indentation,\n            getCellClass(column),\n            rowData?.nestedRows ? ' expandable' : ''\n          ].join(' ')\n        \"\n        [attr.data-test-id]=\"testId + '-cell-' + indentation\"\n      >\n        <ng-container *ngIf=\"rowData?.nestedRows\">\n          <qd-icon\n            *ngIf=\"!expanded\"\n            class=\"expander\"\n            [attr.data-test-id]=\"testId + '-opening-expander'\"\n            [icon]=\"'ctrlRight'\"\n          ></qd-icon>\n          <qd-icon *ngIf=\"expanded\" class=\"expander\" [icon]=\"'ctrlDown'\"></qd-icon>\n        </ng-container>\n\n        <ng-container *ngFor=\"let groupedColumn of $any(column).groupedColumns; let itemIndex = index\">\n          <span *ngIf=\"rowData[groupedColumn.column]\">{{ rowData[groupedColumn.column] }}</span>\n        </ng-container>\n      </td>\n    </ng-container>\n\n    <ng-container *ngIf=\"column.type !== 'group'\">\n      <td [class]=\"'qd-tree-body-cell ' + getCellClass(column)\">\n        <ng-container *ngComponentOutlet=\"getComponentType(column); inputs: getComponentInputs(column)\"></ng-container>\n      </td>\n    </ng-container>\n  </ng-container>\n</ng-container>\n\n<td\n  *ngIf=\"config.secondaryActions?.length > 0\"\n  class=\"qd-tree-body-cell\"\n  [attr.data-test-id]=\"testId + '-cell-inline-actions'\"\n  qd-tree-row-actions-secondary-menu\n  [config]=\"config\"\n  [rowIndex]=\"columnsDetails[0].index\"\n  [rowData]=\"rowData\"\n  [testId]=\"testId + '-secondary-actions'\"\n></td>\n", styles: ["[qd-tree-row] .qd-data-facets{display:block}[qd-tree-row] qd-data-facets-progress.qd-data-facets{transform:translateY(.1875rem)}[qd-tree-row] qd-data-facets-chip.qd-data-facets{display:contents}[qd-tree-row] .qd-table__body-cell--merged qd-data-facets-text{padding-top:0}\n"], dependencies: [{ kind: "directive", type: i2.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { kind: "directive", type: i2.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { kind: "component", type: i3.QdIconComponent, selector: "qd-icon", inputs: ["icon"] }, { kind: "component", type: i4.QdTreeRowActionsSecondaryMenuComponent, selector: "[qd-tree-row-actions-secondary-menu]", inputs: ["rowIndex", "rowData", "config", "testId"] }], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTreeRowComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[qd-tree-row]', encapsulation: ViewEncapsulation.None, providers: [QdDataFacetsContextService], template: "<ng-container *ngFor=\"let column of columnsDetails\">\n  <ng-container [ngSwitch]=\"column.type\">\n    <ng-container *ngSwitchCase=\"'group'\">\n      <td\n        (click)=\"onExpanderClick()\"\n        [class]=\"\n          [\n            'qd-tree-body-cell',\n            'qd-tree-body-cell-group',\n            'qd-tree-body-cell-group-index-' + indentation,\n            getCellClass(column),\n            rowData?.nestedRows ? ' expandable' : ''\n          ].join(' ')\n        \"\n        [attr.data-test-id]=\"testId + '-cell-' + indentation\"\n      >\n        <ng-container *ngIf=\"rowData?.nestedRows\">\n          <qd-icon\n            *ngIf=\"!expanded\"\n            class=\"expander\"\n            [attr.data-test-id]=\"testId + '-opening-expander'\"\n            [icon]=\"'ctrlRight'\"\n          ></qd-icon>\n          <qd-icon *ngIf=\"expanded\" class=\"expander\" [icon]=\"'ctrlDown'\"></qd-icon>\n        </ng-container>\n\n        <ng-container *ngFor=\"let groupedColumn of $any(column).groupedColumns; let itemIndex = index\">\n          <span *ngIf=\"rowData[groupedColumn.column]\">{{ rowData[groupedColumn.column] }}</span>\n        </ng-container>\n      </td>\n    </ng-container>\n\n    <ng-container *ngIf=\"column.type !== 'group'\">\n      <td [class]=\"'qd-tree-body-cell ' + getCellClass(column)\">\n        <ng-container *ngComponentOutlet=\"getComponentType(column); inputs: getComponentInputs(column)\"></ng-container>\n      </td>\n    </ng-container>\n  </ng-container>\n</ng-container>\n\n<td\n  *ngIf=\"config.secondaryActions?.length > 0\"\n  class=\"qd-tree-body-cell\"\n  [attr.data-test-id]=\"testId + '-cell-inline-actions'\"\n  qd-tree-row-actions-secondary-menu\n  [config]=\"config\"\n  [rowIndex]=\"columnsDetails[0].index\"\n  [rowData]=\"rowData\"\n  [testId]=\"testId + '-secondary-actions'\"\n></td>\n", styles: ["[qd-tree-row] .qd-data-facets{display:block}[qd-tree-row] qd-data-facets-progress.qd-data-facets{transform:translateY(.1875rem)}[qd-tree-row] qd-data-facets-chip.qd-data-facets{display:contents}[qd-tree-row] .qd-table__body-cell--merged qd-data-facets-text{padding-top:0}\n"] }]
+        }], ctorParameters: () => [{ type: i1.QdDataFacetsContextService }], propDecorators: { columnsDetails: [{
+                type: Input
+            }], indentation: [{
+                type: Input
+            }], config: [{
+                type: Input,
+                args: [{ required: true }]
+            }], testId: [{
+                type: Input,
+                args: ['data-test-id']
+            }], rowData: [{
+                type: Input
+            }], rowIndex: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-row.component.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/tree/row/tree-row.component.ts","../../../../../../libs/qd-ui/src/lib/tree/row/tree-row.component.html"],"names":[],"mappings":"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","sourcesContent":["// @ts-strict-ignore\nimport { Component, Input, Type, ViewEncapsulation } from '@angular/core';\n\nimport { QdDataFacetsContextService } from '../../core/data-facets/data-facets-context.service';\nimport { COMPONENT_MAP } from '../../core/data-facets/data-facets.model';\nimport { QdColumnDetails, QdColumnsDetails } from '../model/tree-column-detail.interface';\nimport { QdTreeDataRow } from '../model/tree-data.interface';\nimport { QdTreeConfig } from '../model/tree-config.interface';\n\n@Component({\n  selector: '[qd-tree-row]',\n  templateUrl: './tree-row.component.html',\n  styleUrls: ['./tree-row.component.scss'],\n  encapsulation: ViewEncapsulation.None,\n  providers: [QdDataFacetsContextService]\n})\nexport class QdTreeRowComponent<T extends string> {\n  @Input() columnsDetails?: QdColumnsDetails<T>;\n  @Input() indentation = 0;\n  @Input({ required: true }) config!: QdTreeConfig<T>;\n  @Input('data-test-id') testId!: string;\n\n  @Input()\n  set rowData(data: QdTreeDataRow<T>) {\n    this._rowData = data;\n    this.contextService.setContext(data);\n    this.expanded = data.expanded ?? false;\n  }\n\n  get rowData(): QdTreeDataRow<T> {\n    return this._rowData;\n  }\n\n  @Input()\n  set rowIndex(index: number) {\n    this._rowIndex = index;\n    this.contextService.setContext({ index });\n  }\n\n  get rowIndex(): number {\n    return this._rowIndex;\n  }\n\n  expanded = false;\n\n  private _rowData!: QdTreeDataRow<T>;\n  private _rowIndex!: number;\n\n  constructor(private readonly contextService: QdDataFacetsContextService) {}\n\n  onExpanderClick(): void {\n    this.expanded = !this.expanded;\n  }\n\n  getCellClass(column: QdColumnDetails<T>): string {\n    let className = '';\n\n    if (column.isMainColumn) className += ' main-column';\n    if (column.isLastColumn) className += ' last-column';\n\n    return className;\n  }\n\n  getComponentType(item: any): Type<unknown> {\n    return COMPONENT_MAP[item.type];\n  }\n\n  getComponentInputs(item: any): any {\n    const i18n = item.i18n;\n    const config = item.options;\n    const data = this.rowData[item.column];\n    const testId = this.testId + '-cell-' + item.index;\n\n    const isTranslated = item.options && item.options.isTranslated !== undefined;\n\n    return {\n      ...(data && { data }),\n      ...(config && { config }),\n      ...(i18n && isTranslated && { i18n }),\n      ...(testId && { testId })\n    };\n  }\n}\n","<ng-container *ngFor=\"let column of columnsDetails\">\n  <ng-container [ngSwitch]=\"column.type\">\n    <ng-container *ngSwitchCase=\"'group'\">\n      <td\n        (click)=\"onExpanderClick()\"\n        [class]=\"\n          [\n            'qd-tree-body-cell',\n            'qd-tree-body-cell-group',\n            'qd-tree-body-cell-group-index-' + indentation,\n            getCellClass(column),\n            rowData?.nestedRows ? ' expandable' : ''\n          ].join(' ')\n        \"\n        [attr.data-test-id]=\"testId + '-cell-' + indentation\"\n      >\n        <ng-container *ngIf=\"rowData?.nestedRows\">\n          <qd-icon\n            *ngIf=\"!expanded\"\n            class=\"expander\"\n            [attr.data-test-id]=\"testId + '-opening-expander'\"\n            [icon]=\"'ctrlRight'\"\n          ></qd-icon>\n          <qd-icon *ngIf=\"expanded\" class=\"expander\" [icon]=\"'ctrlDown'\"></qd-icon>\n        </ng-container>\n\n        <ng-container *ngFor=\"let groupedColumn of $any(column).groupedColumns; let itemIndex = index\">\n          <span *ngIf=\"rowData[groupedColumn.column]\">{{ rowData[groupedColumn.column] }}</span>\n        </ng-container>\n      </td>\n    </ng-container>\n\n    <ng-container *ngIf=\"column.type !== 'group'\">\n      <td [class]=\"'qd-tree-body-cell ' + getCellClass(column)\">\n        <ng-container *ngComponentOutlet=\"getComponentType(column); inputs: getComponentInputs(column)\"></ng-container>\n      </td>\n    </ng-container>\n  </ng-container>\n</ng-container>\n\n<td\n  *ngIf=\"config.secondaryActions?.length > 0\"\n  class=\"qd-tree-body-cell\"\n  [attr.data-test-id]=\"testId + '-cell-inline-actions'\"\n  qd-tree-row-actions-secondary-menu\n  [config]=\"config\"\n  [rowIndex]=\"columnsDetails[0].index\"\n  [rowData]=\"rowData\"\n  [testId]=\"testId + '-secondary-actions'\"\n></td>\n"]}

package/esm2022/lib/tree/services/row-expander.service.mjs

@@ -0,0 +1,117 @@
+import { DestroyRef, inject, Injectable } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+/**
+ * The **QdTreeRowExpanderService** allows you to expand certain rows by conditions and close all rows.
+ *
+ * **Expand rows**
+ * To expand rows, simply inject the QdTreeRowExpanderService and use expandAll or expandWithCondition depending on yourneeds.
+ * For both you need to provide the QdTree's that should be expanded:
+ *
+ * ```ts
+ * treeRowExpanderService.expandWithCondition("my-tree-id", (row) => row.category === 'delivery');
+ * ```
+ *
+ * Additionally you can also expand rows by data that is not shown in the tree but available in your provided data in QdTree. For this
+ * simply use the second argument of the expression and determine on that:
+ *
+ * ```ts
+ * treeRowExpanderService.expandWithCondition("my-tree-id", (row, record) => record.hiddenId = "12");
+ * ```
+ *
+ * Please be aware that a record will only be provided for the rows that are leafs / have no children.
+ */
+export class QdTreeRowExpanderService {
+    trees = new Map();
+    destroyRef = inject(DestroyRef);
+    init(treeId, rowService) {
+        this.trees.set(treeId, { treeRows: [], rowService });
+        rowService.treeRow$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(tree => {
+            if (tree)
+                this.trees.get(treeId).treeRows = tree;
+        });
+    }
+    /**
+     * Expands all rows.
+     * @param treeId The QdTree's ID
+     */
+    expandAll(treeId) {
+        const tree = this.trees.get(treeId);
+        if (!tree || !tree.treeRows || !tree.treeRows.length)
+            return;
+        tree.treeRows.forEach(row => {
+            this.expand(row);
+        });
+        tree.rowService?.updateRows(JSON.parse(JSON.stringify(tree.treeRows)));
+    }
+    /**
+     * Closes all rows.
+     * @param treeId The QdTree's ID
+     */
+    closeAll(treeId) {
+        const tree = this.trees.get(treeId);
+        if (!tree || !tree.treeRows || !tree.treeRows.length)
+            return;
+        tree.treeRows.forEach(row => {
+            this.close(row);
+        });
+        tree.rowService?.updateRows(JSON.parse(JSON.stringify(tree.treeRows)));
+    }
+    /**
+     * Expands rows by certain condition.
+     * @param treeId The QdTree's ID
+     * @param condition Condition that matches the rows to expand
+     */
+    expandWithCondition(treeId, condition) {
+        const tree = this.trees.get(treeId);
+        if (!tree || tree.treeRows.length === 0)
+            return;
+        tree.treeRows.forEach((row) => {
+            this.traverseAndExpand(row, condition, []);
+        });
+        tree.rowService?.updateRows(JSON.parse(JSON.stringify(tree.treeRows)));
+    }
+    expand(row) {
+        if (!row || !row.nestedRows || !row.nestedRows.length)
+            return;
+        row.nestedRows.forEach(nestedRow => {
+            this.expand(nestedRow);
+        });
+        row.expanded = true;
+    }
+    close(row) {
+        if (!row || !row.nestedRows || !row.nestedRows.length)
+            return;
+        row.nestedRows.forEach(nestedRow => {
+            this.close(nestedRow);
+        });
+        row.expanded = false;
+    }
+    traverseAndExpand(row, condition, ancestorChain) {
+        let shouldExpand = false;
+        // Check if the current row meets the condition
+        if (condition(row, row.full ?? {})) {
+            shouldExpand = true;
+            this.expand(row);
+        }
+        // Traverse nested rows
+        if (row.nestedRows && row.nestedRows.length > 0) {
+            row.nestedRows.forEach(nestedRow => {
+                if (this.traverseAndExpand(nestedRow, condition, [...ancestorChain, row])) {
+                    shouldExpand = true;
+                }
+            });
+        }
+        // Expand ancestor rows if necessary
+        if (shouldExpand) {
+            ancestorChain.forEach(ancestor => (ancestor.expanded = true));
+        }
+        return shouldExpand;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTreeRowExpanderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTreeRowExpanderService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTreeRowExpanderService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"row-expander.service.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/tree/services/row-expander.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DestroyRef, inject, Injectable } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { QdTreeDataRow } from '../model/tree-data.interface';\nimport { QdTreeRowsService } from './tree-rows.service';\n\ntype QdTreeDataRowWithRecord<T extends string> = QdTreeDataRow<T> & { full: QdTreeDataRow<T> };\n\n/**\n * The **QdTreeRowExpanderService** allows you to expand certain rows by conditions and close all rows.\n *\n * **Expand rows**\n * To expand rows, simply inject the QdTreeRowExpanderService and use expandAll or expandWithCondition depending on yourneeds.\n * For both you need to provide the QdTree's that should be expanded:\n *\n * ```ts\n * treeRowExpanderService.expandWithCondition(\"my-tree-id\", (row) => row.category === 'delivery');\n * ```\n *\n * Additionally you can also expand rows by data that is not shown in the tree but available in your provided data in QdTree. For this\n * simply use the second argument of the expression and determine on that:\n *\n * ```ts\n * treeRowExpanderService.expandWithCondition(\"my-tree-id\", (row, record) => record.hiddenId = \"12\");\n * ```\n *\n * Please be aware that a record will only be provided for the rows that are leafs / have no children.\n */\n@Injectable()\nexport class QdTreeRowExpanderService<T extends string> {\n  trees = new Map<string, { treeRows: QdTreeDataRow<T>[]; rowService: QdTreeRowsService<T> }>();\n\n  destroyRef = inject(DestroyRef);\n\n  init(treeId: string, rowService: QdTreeRowsService<T>): void {\n    this.trees.set(treeId, { treeRows: [], rowService });\n    rowService.treeRow$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(tree => {\n      if (tree) this.trees.get(treeId)!.treeRows = tree;\n    });\n  }\n\n  /**\n   * Expands all rows.\n   * @param treeId The QdTree's ID\n   */\n  expandAll(treeId: string): void {\n    const tree = this.trees.get(treeId);\n    if (!tree || !tree.treeRows || !tree.treeRows.length) return;\n\n    tree.treeRows.forEach(row => {\n      this.expand(row);\n    });\n    tree.rowService?.updateRows(JSON.parse(JSON.stringify(tree.treeRows)));\n  }\n\n  /**\n   * Closes all rows.\n   * @param treeId The QdTree's ID\n   */\n  closeAll(treeId: string): void {\n    const tree = this.trees.get(treeId);\n\n    if (!tree || !tree.treeRows || !tree.treeRows.length) return;\n\n    tree.treeRows.forEach(row => {\n      this.close(row);\n    });\n    tree.rowService?.updateRows(JSON.parse(JSON.stringify(tree.treeRows)));\n  }\n\n  /**\n   * Expands rows by certain condition.\n   * @param treeId The QdTree's ID\n   * @param condition Condition that matches the rows to expand\n   */\n  expandWithCondition(treeId: string, condition: (row: QdTreeDataRow<T>, record?: QdTreeDataRow<T>) => boolean): void {\n    const tree = this.trees.get(treeId);\n\n    if (!tree || tree.treeRows.length === 0) return;\n\n    tree.treeRows.forEach((row: QdTreeDataRow<T>) => {\n      this.traverseAndExpand(row, condition, []);\n    });\n\n    tree.rowService?.updateRows(JSON.parse(JSON.stringify(tree.treeRows)));\n  }\n\n  private expand(row: QdTreeDataRow<T>): void {\n    if (!row || !row.nestedRows || !row.nestedRows.length) return;\n\n    row.nestedRows.forEach(nestedRow => {\n      this.expand(nestedRow);\n    });\n    row.expanded = true;\n  }\n\n  private close(row: QdTreeDataRow<T>): void {\n    if (!row || !row.nestedRows || !row.nestedRows.length) return;\n\n    row.nestedRows.forEach(nestedRow => {\n      this.close(nestedRow);\n    });\n    row.expanded = false;\n  }\n\n  private traverseAndExpand(\n    row: QdTreeDataRow<T> | QdTreeDataRowWithRecord<T>,\n    condition: (row: QdTreeDataRow<T> | any, record?: QdTreeDataRow<T>) => boolean,\n    ancestorChain: QdTreeDataRow<T>[]\n  ): boolean {\n    let shouldExpand = false;\n\n    // Check if the current row meets the condition\n    if (condition(row, (row as QdTreeDataRowWithRecord<T>).full ?? {})) {\n      shouldExpand = true;\n      this.expand(row);\n    }\n\n    // Traverse nested rows\n    if (row.nestedRows && row.nestedRows.length > 0) {\n      row.nestedRows.forEach(nestedRow => {\n        if (this.traverseAndExpand(nestedRow, condition, [...ancestorChain, row])) {\n          shouldExpand = true;\n        }\n      });\n    }\n\n    // Expand ancestor rows if necessary\n    if (shouldExpand) {\n      ancestorChain.forEach(ancestor => (ancestor.expanded = true));\n    }\n\n    return shouldExpand;\n  }\n}\n"]}

package/esm2022/lib/tree/services/tree-group.service.mjs

@@ -0,0 +1,87 @@
+// @ts-strict-ignore
+import { Injectable } from '@angular/core';
+import { QdGroupedIndicesNotConsecutiveError } from '../error/grouped-indices-not-consecutive.error';
+import * as i0 from "@angular/core";
+export class QdTreeGroupService {
+    config;
+    columnsDetails = [];
+    groupColumn;
+    ungroupedColumns;
+    /**
+     * Groups columns that matches the given function and returns resulting columns with details.
+     *
+     * @param config table config
+     * @param isColumnGrouped function to define the grouping condition
+     * @throws QdGroupedIndicesNotConsecutiveError
+     */
+    initialize(config, isColumnGrouped) {
+        this.config = config;
+        this.columnsDetails = this.getColumnsDetailsAfterGrouping(isColumnGrouped);
+        this.groupColumn = this.columnsDetails.find(column => column.type === 'group');
+        this.ungroupedColumns = this.columnsDetails.filter(column => column.type !== 'group');
+    }
+    updateTableConfig(config, isColumnGrouped) {
+        this.initialize(config, isColumnGrouped);
+    }
+    getColumnsDetailsAfterGrouping(isColumnGrouped) {
+        const groupedColumnsIndices = this.getGroupedColumnsIndices(isColumnGrouped);
+        const columnsWithGroupedColumns = this.groupIndices(this.config.columns, groupedColumnsIndices);
+        return columnsWithGroupedColumns.map((columnOrGroupedColumns, columnIndex) => {
+            const isLastColumn = columnsWithGroupedColumns.length - 1 === columnIndex;
+            return Array.isArray(columnOrGroupedColumns)
+                ? this.getGroupColumnDetails(columnOrGroupedColumns, columnIndex, isLastColumn)
+                : this.getColumnDetails(columnOrGroupedColumns, columnIndex, isLastColumn);
+        });
+    }
+    getGroupedColumnsIndices(isColumnGrouped) {
+        return this.config.columns
+            .map((column, columnIndex) => (isColumnGrouped(column) ? columnIndex : null))
+            .filter(index => index !== null);
+    }
+    groupIndices(array, groupedIndices) {
+        if (groupedIndices.length === 0)
+            return array;
+        if (!this.areNumbersConsecutive(groupedIndices)) {
+            throw new QdGroupedIndicesNotConsecutiveError(groupedIndices);
+        }
+        const arrayCopy = [...array];
+        // TODO use toSpliced with ES2024
+        arrayCopy.splice(groupedIndices[0], groupedIndices.length, groupedIndices.map(index => array[index]));
+        return arrayCopy;
+    }
+    areNumbersConsecutive(numbers) {
+        return numbers.every((_number, index) => {
+            const nextNumber = numbers[index + 1];
+            return nextNumber === undefined || nextNumber - _number === 1;
+        });
+    }
+    getGroupColumnDetails(groupedColumns, columnIndex, isLastColumn) {
+        return {
+            index: columnIndex,
+            type: 'group',
+            isMainColumn: groupedColumns.some(column => column.column === this.getMainColumn()),
+            isLastColumn,
+            groupedColumns: groupedColumns.map(column => this.getColumnDetails(column, columnIndex, isLastColumn))
+        };
+    }
+    getColumnDetails(column, columnIndex, isLastColumn) {
+        return {
+            index: columnIndex,
+            column: column.column,
+            type: column.type,
+            options: column.options,
+            i18n: this.config.i18ns ? `${this.config.i18ns}.${column.column}` : undefined,
+            isMainColumn: column.column === this.getMainColumn(),
+            isLastColumn
+        };
+    }
+    getMainColumn() {
+        return this.config.mainColumn || this.config.columns[0].column;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTreeGroupService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTreeGroupService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTreeGroupService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-group.service.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/tree/services/tree-group.service.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,mCAAmC,EAAE,MAAM,gDAAgD,CAAC;;AAKrG,MAAM,OAAO,kBAAkB;IAC7B,MAAM,CAAkB;IACxB,cAAc,GAAwB,EAAE,CAAC;IACzC,WAAW,CAA0B;IACrC,gBAAgB,CAAuB;IAEvC;;;;;;OAMG;IACH,UAAU,CAAC,MAAuB,EAAE,eAA2D;QAC7F,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,8BAA8B,CAAC,eAAe,CAAC,CAAC;QAC3E,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,OAAO,CAA4B,CAAC;QAC1G,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,OAAO,CAAyB,CAAC;IAChH,CAAC;IAED,iBAAiB,CAAC,MAAuB,EAAE,eAA2D;QACpG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC3C,CAAC;IAEO,8BAA8B,CACpC,eAA2D;QAE3D,MAAM,qBAAqB,GAAG,IAAI,CAAC,wBAAwB,CAAC,eAAe,CAAC,CAAC;QAC7E,MAAM,yBAAyB,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,qBAAqB,CAAC,CAAC;QAEhG,OAAO,yBAAyB,CAAC,GAAG,CAAC,CAAC,sBAAsB,EAAE,WAAW,EAAE,EAAE;YAC3E,MAAM,YAAY,GAAG,yBAAyB,CAAC,MAAM,GAAG,CAAC,KAAK,WAAW,CAAC;YAE1E,OAAO,KAAK,CAAC,OAAO,CAAC,sBAAsB,CAAC;gBAC1C,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,sBAAsB,EAAE,WAAW,EAAE,YAAY,CAAC;gBAC/E,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,sBAAsB,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC;QAC/E,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,wBAAwB,CAAC,eAA2D;QAC1F,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO;aACvB,GAAG,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,EAAE,CAAC,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;aAC5E,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC;IACrC,CAAC;IAEO,YAAY,CAAI,KAAe,EAAE,cAAwB;QAC/D,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAE9C,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,cAAc,CAAC,EAAE,CAAC;YAChD,MAAM,IAAI,mCAAmC,CAAC,cAAc,CAAC,CAAC;QAChE,CAAC;QAED,MAAM,SAAS,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;QAE7B,iCAAiC;QACjC,SAAS,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAQ,CAAC,CAAC;QAE7G,OAAO,SAAS,CAAC;IACnB,CAAC;IAEO,qBAAqB,CAAC,OAAiB;QAC7C,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;YACtC,MAAM,UAAU,GAAG,OAAO,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;YACtC,OAAO,UAAU,KAAK,SAAS,IAAI,UAAU,GAAG,OAAO,KAAK,CAAC,CAAC;QAChE,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,qBAAqB,CAC3B,cAA4C,EAC5C,WAAmB,EACnB,YAAqB;QAErB,OAAO;YACL,KAAK,EAAE,WAAW;YAClB,IAAI,EAAE,OAAO;YACb,YAAY,EAAE,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,KAAK,IAAI,CAAC,aAAa,EAAE,CAAC;YACnF,YAAY;YACZ,cAAc,EAAE,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC;SACvG,CAAC;IACJ,CAAC;IAEO,gBAAgB,CACtB,MAA6B,EAC7B,WAAmB,EACnB,YAAqB;QAErB,OAAO;YACL,KAAK,EAAE,WAAW;YAClB,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,OAAO,EAAG,MAAc,CAAC,OAAO;YAChC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,SAAS;YAC7E,YAAY,EAAE,MAAM,CAAC,MAAM,KAAK,IAAI,CAAC,aAAa,EAAE;YACpD,YAAY;SACb,CAAC;IACJ,CAAC;IAEO,aAAa;QACnB,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IACjE,CAAC;uGAnGU,kBAAkB;2GAAlB,kBAAkB;;2FAAlB,kBAAkB;kBAD9B,UAAU","sourcesContent":["// @ts-strict-ignore\nimport { Injectable } from '@angular/core';\n\nimport { QdGroupedIndicesNotConsecutiveError } from '../error/grouped-indices-not-consecutive.error';\nimport { QdColumnDetails, QdColumnsDetails, QdGroupColumnDetails } from '../model/tree-column-detail.interface';\nimport { QdTreeConfig, QdTreeConfigColumn } from '../model/tree-config.interface';\n\n@Injectable()\nexport class QdTreeGroupService<T extends string> {\n  config: QdTreeConfig<T>;\n  columnsDetails: QdColumnsDetails<T> = [];\n  groupColumn: QdGroupColumnDetails<T>;\n  ungroupedColumns: QdColumnDetails<T>[];\n\n  /**\n   * Groups columns that matches the given function and returns resulting columns with details.\n   *\n   * @param config table config\n   * @param isColumnGrouped function to define the grouping condition\n   * @throws QdGroupedIndicesNotConsecutiveError\n   */\n  initialize(config: QdTreeConfig<T>, isColumnGrouped: (column: QdTreeConfigColumn<T>) => boolean): void {\n    this.config = config;\n    this.columnsDetails = this.getColumnsDetailsAfterGrouping(isColumnGrouped);\n    this.groupColumn = this.columnsDetails.find(column => column.type === 'group') as QdGroupColumnDetails<T>;\n    this.ungroupedColumns = this.columnsDetails.filter(column => column.type !== 'group') as QdColumnDetails<T>[];\n  }\n\n  updateTableConfig(config: QdTreeConfig<T>, isColumnGrouped: (column: QdTreeConfigColumn<T>) => boolean): void {\n    this.initialize(config, isColumnGrouped);\n  }\n\n  private getColumnsDetailsAfterGrouping(\n    isColumnGrouped: (column: QdTreeConfigColumn<T>) => boolean\n  ): QdColumnsDetails<T> {\n    const groupedColumnsIndices = this.getGroupedColumnsIndices(isColumnGrouped);\n    const columnsWithGroupedColumns = this.groupIndices(this.config.columns, groupedColumnsIndices);\n\n    return columnsWithGroupedColumns.map((columnOrGroupedColumns, columnIndex) => {\n      const isLastColumn = columnsWithGroupedColumns.length - 1 === columnIndex;\n\n      return Array.isArray(columnOrGroupedColumns)\n        ? this.getGroupColumnDetails(columnOrGroupedColumns, columnIndex, isLastColumn)\n        : this.getColumnDetails(columnOrGroupedColumns, columnIndex, isLastColumn);\n    });\n  }\n\n  private getGroupedColumnsIndices(isColumnGrouped: (column: QdTreeConfigColumn<T>) => boolean): number[] {\n    return this.config.columns\n      .map((column, columnIndex) => (isColumnGrouped(column) ? columnIndex : null))\n      .filter(index => index !== null);\n  }\n\n  private groupIndices<U>(array: Array<U>, groupedIndices: number[]): Array<U | U[]> {\n    if (groupedIndices.length === 0) return array;\n\n    if (!this.areNumbersConsecutive(groupedIndices)) {\n      throw new QdGroupedIndicesNotConsecutiveError(groupedIndices);\n    }\n\n    const arrayCopy = [...array];\n\n    // TODO use toSpliced with ES2024\n    arrayCopy.splice(groupedIndices[0], groupedIndices.length, groupedIndices.map(index => array[index]) as any);\n\n    return arrayCopy;\n  }\n\n  private areNumbersConsecutive(numbers: number[]): boolean {\n    return numbers.every((_number, index) => {\n      const nextNumber = numbers[index + 1];\n      return nextNumber === undefined || nextNumber - _number === 1;\n    });\n  }\n\n  private getGroupColumnDetails(\n    groupedColumns: Array<QdTreeConfigColumn<T>>,\n    columnIndex: number,\n    isLastColumn: boolean\n  ): QdGroupColumnDetails<T> {\n    return {\n      index: columnIndex,\n      type: 'group',\n      isMainColumn: groupedColumns.some(column => column.column === this.getMainColumn()),\n      isLastColumn,\n      groupedColumns: groupedColumns.map(column => this.getColumnDetails(column, columnIndex, isLastColumn))\n    };\n  }\n\n  private getColumnDetails(\n    column: QdTreeConfigColumn<T>,\n    columnIndex: number,\n    isLastColumn: boolean\n  ): QdColumnDetails<T> {\n    return {\n      index: columnIndex,\n      column: column.column,\n      type: column.type,\n      options: (column as any).options,\n      i18n: this.config.i18ns ? `${this.config.i18ns}.${column.column}` : undefined,\n      isMainColumn: column.column === this.getMainColumn(),\n      isLastColumn\n    };\n  }\n\n  private getMainColumn(): T {\n    return this.config.mainColumn || this.config.columns[0].column;\n  }\n}\n"]}

package/esm2022/lib/tree/services/tree-rows.service.mjs

@@ -0,0 +1,151 @@
+// @ts-strict-ignore
+import { Injectable, Optional } from '@angular/core';
+import { cloneDeep, isEqual, isNumber, union } from 'lodash';
+import { BehaviorSubject } from 'rxjs';
+import { QdTreeRowExpanderService } from './row-expander.service';
+import { QdTreeGroupService } from './tree-group.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./tree-group.service";
+import * as i2 from "./row-expander.service";
+export class QdTreeRowsService {
+    groupService;
+    expanderService;
+    config;
+    treeRowSubject = new BehaviorSubject(null);
+    treeRow$ = this.treeRowSubject.asObservable();
+    constructor(groupService, expanderService) {
+        this.groupService = groupService;
+        this.expanderService = expanderService;
+    }
+    get groupColumn() {
+        return this.groupService.groupColumn;
+    }
+    initializeRows(data) {
+        const rows = cloneDeep(data);
+        let treeRows = this.splitRowsByTree(rows);
+        if (this.config?.group?.aggregation) {
+            treeRows = this.aggregateRows(treeRows);
+            this.sortRowsByNumbers(treeRows); // previous aggregation logic used object keys (numbers are sorted in object keys)
+        }
+        this.treeRowSubject.next(treeRows);
+    }
+    initializeConfig(config) {
+        this.config = config;
+        this.expanderService.init(this.config?.uid, this);
+    }
+    updateRows(data) {
+        this.treeRowSubject.next(data);
+    }
+    get ungroupedColumns() {
+        return this.groupService.ungroupedColumns;
+    }
+    splitRowsByTree(rows) {
+        rows.forEach(row => {
+            if (row.nestedRows) {
+                row.nestedRows = this.splitRowsByTree(row.nestedRows);
+            }
+        });
+        return rows.map(this.splitRowByTree.bind(this));
+    }
+    splitRowByTree(row) {
+        const treeRows = [];
+        if (this.groupColumn) {
+            this.groupColumn.groupedColumns.forEach(groupedColumn => {
+                if (row[groupedColumn.column]) {
+                    treeRows.push({ [groupedColumn.column]: row[groupedColumn.column] });
+                }
+            });
+        }
+        if (treeRows.length === 0) {
+            treeRows.push(row);
+        }
+        else {
+            const lastTreeRow = treeRows[treeRows.length - 1];
+            this.ungroupedColumns.forEach(column => {
+                lastTreeRow[column.column] = row[column.column];
+            });
+            if (row.uid)
+                lastTreeRow.uid = row.uid;
+            lastTreeRow.nestedRows = row.nestedRows;
+            if (!this.config?.group?.aggregation || !lastTreeRow.nestedRows)
+                lastTreeRow.full = row;
+        }
+        return this.nestRowsIntoOneAnother(treeRows);
+    }
+    nestRowsIntoOneAnother(rows) {
+        let rootRow = rows[0];
+        for (let index = 1; index < rows.length; index++) {
+            const nextRow = rows[index];
+            rootRow.nestedRows = [nextRow];
+            rootRow = nextRow;
+        }
+        return rows[0];
+    }
+    aggregateRows(data) {
+        const rows = cloneDeep(data);
+        const sameRowsGroups = this.groupArray(rows, this.areRowsEqual.bind(this));
+        return sameRowsGroups.map(sameRows => {
+            const firstSameRow = sameRows[0];
+            for (let index = 1; index < sameRows.length; index++) {
+                const otherSameRow = sameRows[index];
+                if (otherSameRow.nestedRows) {
+                    if (!firstSameRow.nestedRows)
+                        firstSameRow.nestedRows = [];
+                    otherSameRow.nestedRows.forEach(nestedRow => {
+                        firstSameRow.nestedRows.push(nestedRow);
+                    });
+                }
+            }
+            if (firstSameRow.nestedRows) {
+                firstSameRow.nestedRows = this.aggregateRows(firstSameRow.nestedRows);
+            }
+            return firstSameRow;
+        });
+    }
+    groupArray(array, areItemsEqual) {
+        const sameItemsGroups = [];
+        const ungroupedItems = [...array];
+        while (ungroupedItems.length > 0) {
+            const item = ungroupedItems.shift();
+            const sameItems = [item];
+            let comparedItemIndex = 0;
+            while (comparedItemIndex < ungroupedItems.length) {
+                const comparedItem = ungroupedItems[comparedItemIndex];
+                if (areItemsEqual(item, comparedItem)) {
+                    sameItems.push(comparedItem);
+                    ungroupedItems.splice(comparedItemIndex, 1);
+                }
+                else {
+                    comparedItemIndex++;
+                }
+            }
+            sameItemsGroups.push(sameItems);
+        }
+        return sameItemsGroups;
+    }
+    areRowsEqual(row, comparedRow) {
+        return this.getRowsProperties([row, comparedRow]).every(property => isEqual(row[property], comparedRow[property]));
+    }
+    getRowsProperties(rows) {
+        return union(rows.map(row => Object.keys(row)).flat()).filter(property => property !== 'nestedRows' && property !== 'full');
+    }
+    sortRowsByNumbers(rows) {
+        rows.forEach(row => {
+            if (row.nestedRows) {
+                this.sortRowsByNumbers(row.nestedRows);
+            }
+        });
+        const properties = this.getRowsProperties(rows);
+        if (properties.length === 1 && rows.every(row => isNumber(row[properties[0]]))) {
+            rows.sort((rowA, rowB) => rowA[properties[0]] - rowB[properties[0]]);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTreeRowsService, deps: [{ token: i1.QdTreeGroupService }, { token: i2.QdTreeRowExpanderService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTreeRowsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdTreeRowsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.QdTreeGroupService }, { type: i2.QdTreeRowExpanderService, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-rows.service.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/tree/services/tree-rows.service.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-strict-ignore\nimport { Injectable, Optional } from '@angular/core';\nimport { cloneDeep, isEqual, isNumber, union } from 'lodash';\n\nimport { BehaviorSubject } from 'rxjs';\nimport { QdColumnDetails, QdGroupColumnDetails } from '../model/tree-column-detail.interface';\nimport { QdTreeConfig } from '../model/tree-config.interface';\nimport { QdTreeData, QdTreeDataRow } from '../model/tree-data.interface';\nimport { QdTreeRowExpanderService } from './row-expander.service';\nimport { QdTreeGroupService } from './tree-group.service';\n\n@Injectable()\nexport class QdTreeRowsService<T extends string> {\n  config: QdTreeConfig<T>;\n\n  private treeRowSubject = new BehaviorSubject<QdTreeData<T>>(null);\n  treeRow$ = this.treeRowSubject.asObservable();\n\n  constructor(\n    private groupService: QdTreeGroupService<T>,\n    @Optional() private expanderService: QdTreeRowExpanderService<T>\n  ) {}\n\n  get groupColumn(): QdGroupColumnDetails<T> {\n    return this.groupService.groupColumn;\n  }\n\n  initializeRows(data: QdTreeData<T>): void {\n    const rows = cloneDeep(data);\n    let treeRows = this.splitRowsByTree(rows);\n\n    if (this.config?.group?.aggregation) {\n      treeRows = this.aggregateRows(treeRows);\n      this.sortRowsByNumbers(treeRows); // previous aggregation logic used object keys (numbers are sorted in object keys)\n    }\n    this.treeRowSubject.next(treeRows);\n  }\n\n  initializeConfig(config: QdTreeConfig<T>): void {\n    this.config = config;\n    this.expanderService.init(this.config?.uid, this);\n  }\n\n  updateRows(data: QdTreeData<T>): void {\n    this.treeRowSubject.next(data);\n  }\n\n  get ungroupedColumns(): QdColumnDetails<T>[] {\n    return this.groupService.ungroupedColumns;\n  }\n\n  private splitRowsByTree(rows: Array<QdTreeDataRow<T>>): Array<QdTreeDataRow<T>> {\n    rows.forEach(row => {\n      if (row.nestedRows) {\n        row.nestedRows = this.splitRowsByTree(row.nestedRows);\n      }\n    });\n\n    return rows.map(this.splitRowByTree.bind(this));\n  }\n\n  private splitRowByTree(row: QdTreeDataRow<T>): QdTreeDataRow<T> {\n    const treeRows = [];\n\n    if (this.groupColumn) {\n      this.groupColumn.groupedColumns.forEach(groupedColumn => {\n        if (row[groupedColumn.column]) {\n          treeRows.push({ [groupedColumn.column]: row[groupedColumn.column] });\n        }\n      });\n    }\n\n    if (treeRows.length === 0) {\n      treeRows.push(row);\n    } else {\n      const lastTreeRow = treeRows[treeRows.length - 1];\n      this.ungroupedColumns.forEach(column => {\n        lastTreeRow[column.column] = row[column.column];\n      });\n\n      if (row.uid) lastTreeRow.uid = row.uid;\n\n      lastTreeRow.nestedRows = row.nestedRows;\n\n      if (!this.config?.group?.aggregation || !lastTreeRow.nestedRows) lastTreeRow.full = row;\n    }\n\n    return this.nestRowsIntoOneAnother(treeRows);\n  }\n\n  private nestRowsIntoOneAnother(rows: QdTreeDataRow<T>[]): QdTreeDataRow<T> {\n    let rootRow = rows[0];\n\n    for (let index = 1; index < rows.length; index++) {\n      const nextRow = rows[index];\n      rootRow.nestedRows = [nextRow];\n      rootRow = nextRow;\n    }\n\n    return rows[0];\n  }\n\n  private aggregateRows(data: QdTreeData<T>): QdTreeData<T> {\n    const rows = cloneDeep(data);\n    const sameRowsGroups = this.groupArray<QdTreeDataRow<T>>(rows, this.areRowsEqual.bind(this));\n\n    return sameRowsGroups.map(sameRows => {\n      const firstSameRow = sameRows[0];\n\n      for (let index = 1; index < sameRows.length; index++) {\n        const otherSameRow = sameRows[index];\n\n        if (otherSameRow.nestedRows) {\n          if (!firstSameRow.nestedRows) firstSameRow.nestedRows = [];\n\n          otherSameRow.nestedRows.forEach(nestedRow => {\n            firstSameRow.nestedRows.push(nestedRow);\n          });\n        }\n      }\n\n      if (firstSameRow.nestedRows) {\n        firstSameRow.nestedRows = this.aggregateRows(firstSameRow.nestedRows);\n      }\n\n      return firstSameRow;\n    });\n  }\n\n  private groupArray<T>(array: T[], areItemsEqual: (a: T, b: T) => boolean): T[][] {\n    const sameItemsGroups = [];\n    const ungroupedItems = [...array];\n\n    while (ungroupedItems.length > 0) {\n      const item = ungroupedItems.shift();\n      const sameItems = [item];\n\n      let comparedItemIndex = 0;\n\n      while (comparedItemIndex < ungroupedItems.length) {\n        const comparedItem = ungroupedItems[comparedItemIndex];\n\n        if (areItemsEqual(item, comparedItem)) {\n          sameItems.push(comparedItem);\n          ungroupedItems.splice(comparedItemIndex, 1);\n        } else {\n          comparedItemIndex++;\n        }\n      }\n\n      sameItemsGroups.push(sameItems);\n    }\n\n    return sameItemsGroups;\n  }\n\n  private areRowsEqual(row: QdTreeDataRow<T>, comparedRow: QdTreeDataRow<T>): boolean {\n    return this.getRowsProperties([row, comparedRow]).every(property => isEqual(row[property], comparedRow[property]));\n  }\n\n  private getRowsProperties(rows: QdTreeDataRow<T>[]): string[] {\n    return union(rows.map(row => Object.keys(row)).flat()).filter(\n      property => property !== 'nestedRows' && property !== 'full'\n    );\n  }\n\n  private sortRowsByNumbers(rows: QdTreeDataRow<T>[]): void {\n    rows.forEach(row => {\n      if (row.nestedRows) {\n        this.sortRowsByNumbers(row.nestedRows);\n      }\n    });\n\n    const properties = this.getRowsProperties(rows);\n\n    if (properties.length === 1 && rows.every(row => isNumber(row[properties[0]]))) {\n      rows.sort((rowA, rowB) => rowA[properties[0]] - rowB[properties[0]]);\n    }\n  }\n}\n"]}