@progress/kendo-angular-grid 19.1.2 → 19.2.0-develop.10

package/aggregates/selection-aggregate.service.d.ts

@@ -7,7 +7,6 @@ import { CellSelectionItem, SelectionEvent } from '../selection/types';
 import { RowArgs } from '../rendering/common/row-args';
 import { ContextService } from '../common/provider.service';
 import { ColumnInfoService } from '../common/column-info.service';
-import { LocalDataChangesService } from '../editing/local-data-changes.service';
 import * as i0 from "@angular/core";
 /**
  * @hidden
@@ -22,13 +21,12 @@ interface GroupedAggregates {
  */
 export declare class CellSelectionAggregateService {
     private ctx;
-    private dataChanges;
     private columnInfoService;
     selectedItems: Array<CellSelectionItem | RowArgs>;
     groupedAggregates: GroupedAggregates;
     aggregates: SelectionAggregates;
     private sub;
-    constructor(ctx: ContextService, dataChanges: LocalDataChangesService, columnInfoService: ColumnInfoService);
+    constructor(ctx: ContextService, columnInfoService: ColumnInfoService);
     ngOnDestroy(): void;
     isAggregateIncluded(aggregate: SelectionAggregate): boolean;
     init(): void;

package/column-menu/column-menu-item.directive.d.ts

@@ -6,7 +6,7 @@ import { ChangeDetectorRef, ElementRef, NgZone, Renderer2 } from '@angular/core'
 import { ContextService } from '../common/provider.service';
 import * as i0 from "@angular/core";
 /**
- * Represents a directive that manages keyboard navigation for a column menu item. [See example](slug:columnmenu_grid#customizing-the-content).
+ * Represents a directive that manages keyboard navigation for a column menu item ([see example](slug:columnmenu_grid#customizing-the-content)).
  *
  * @example
  * ```html

package/common/provider.service.d.ts

@@ -7,6 +7,7 @@ import { LocalizationService } from '@progress/kendo-angular-l10n';
 import type { GridComponent } from '../grid.component';
 import { GridToolbarNavigationService } from '../rendering/toolbar/toolbar-navigation.service';
 import type { GroupBindingDirective } from '../grouping/group-scroll-binding.directive';
+import { DataBindingDirective } from '../databinding.directive';
 import * as i0 from "@angular/core";
 /**
  * @hidden
@@ -24,7 +25,7 @@ export declare class ContextService {
     topToolbarNavigation: GridToolbarNavigationService;
     bottomToolbarNavigation: GridToolbarNavigationService;
     navigable: boolean;
-    groupBindingDirective: GroupBindingDirective;
+    dataBindingDirective: DataBindingDirective | GroupBindingDirective;
     constructor(renderer: Renderer2, localization: LocalizationService);
     static ɵfac: i0.ɵɵFactoryDeclaration<ContextService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ContextService>;

package/data/data-mapping.service.d.ts

@@ -0,0 +1,46 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2025 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { QueryList } from '@angular/core';
+import { RowspanService } from '../rendering/rowspan.service';
+import { GroupsService } from '../grouping/groups.service';
+import { GridItem } from './grid-item.interface';
+import { DetailsService } from '../rendering/details/details.service';
+import { ColumnBase } from '../columns/column-base';
+import { DetailTemplateDirective } from '../rendering/details/detail-template.directive';
+import * as i0 from "@angular/core";
+/**
+ * @hidden
+ */
+export declare class DataMappingService {
+    private rowspanService;
+    private groupsService;
+    private detailsService;
+    private recalculateRowspan;
+    private dataArray;
+    constructor(rowspanService: RowspanService, groupsService: GroupsService, detailsService: DetailsService);
+    private isGroup;
+    /**
+     * Maps the data to the Grid row items, applying rowspan and detail row logic.
+     */
+    dataMapper(data: any, nonLockedColumnsToRender: QueryList<ColumnBase>, lockedLeafColumns: QueryList<ColumnBase>, detailTemplate: DetailTemplateDirective, showFooter: boolean): Array<GridItem & {
+        showDataItem?: boolean;
+        showDetailRow?: boolean;
+        cells?: any[];
+        isExpanded?: boolean;
+    }>;
+    private isDataItem;
+    private isFooter;
+    private isFooterItemInExpandedGroup;
+    private isDataItemInExpandedGroup;
+    private isInExpandedGroup;
+    private isParentGroupExpanded;
+    private isExpanded;
+    private shouldRenderItem;
+    private shouldSkipCell;
+    private cachedDataArray;
+    private getRowspan;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataMappingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataMappingService>;
+}

package/databinding.directive.d.ts

@@ -10,6 +10,7 @@ import { GridDataResult } from './data/data.collection';
 import { LocalDataChangesService } from './editing/local-data-changes.service';
 import { RowReorderEvent } from './row-reordering/types';
 import { RowReorderService } from './row-reordering/row-reorder.service';
+import { ContextService } from './common/provider.service';
 import * as i0 from "@angular/core";
 /**
  * A directive that handles in-memory data operations like [paging]({% slug paging_grid %}),
@@ -67,7 +68,7 @@ export declare class DataBindingDirective implements OnInit, OnDestroy, DoCheck,
     private stateChangeSubscription;
     private dataChangedSubscription;
     private rowReorderSubscription;
-    constructor(grid: GridComponent, changeDetector?: ChangeDetectorRef, localDataChangesService?: LocalDataChangesService, rowReorderService?: RowReorderService);
+    constructor(grid: GridComponent, changeDetector?: ChangeDetectorRef, localDataChangesService?: LocalDataChangesService, rowReorderService?: RowReorderService, ctx?: ContextService);
     /**
      * @hidden
      */

package/esm2022/aggregates/selection-aggregate.service.mjs

@@ -5,19 +5,16 @@
 import { Injectable } from '@angular/core';
 import { ContextService } from '../common/provider.service';
 import { ColumnInfoService } from '../common/column-info.service';
-import { LocalDataChangesService } from '../editing/local-data-changes.service';
 import { recursiveFlatMap } from '../utils';
 import { Subscription } from 'rxjs';
 import * as i0 from "@angular/core";
 import * as i1 from "../common/provider.service";
-import * as i2 from "../editing/local-data-changes.service";
-import * as i3 from "../common/column-info.service";
+import * as i2 from "../common/column-info.service";
 /**
  * @hidden
  */
 export class CellSelectionAggregateService {
     ctx;
-    dataChanges;
     columnInfoService;
     selectedItems = [];
     groupedAggregates = { dates: [], numbers: [], booleans: [] };
@@ -33,9 +30,8 @@ export class CellSelectionAggregateService {
         latest: null
     };
     sub = new Subscription();
-    constructor(ctx, dataChanges, columnInfoService) {
+    constructor(ctx, columnInfoService) {
         this.ctx = ctx;
-        this.dataChanges = dataChanges;
         this.columnInfoService = columnInfoService;
     }
     ngOnDestroy() {
@@ -196,9 +192,9 @@ export class CellSelectionAggregateService {
         this.aggregates['isFalse'] = this.aggregates['isTrue'] = null;
         this.aggregates['earliest'] = this.aggregates['latest'] = null;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CellSelectionAggregateService, deps: [{ token: i1.ContextService }, { token: i2.LocalDataChangesService }, { token: i3.ColumnInfoService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CellSelectionAggregateService, deps: [{ token: i1.ContextService }, { token: i2.ColumnInfoService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CellSelectionAggregateService });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CellSelectionAggregateService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: i1.ContextService }, { type: i2.LocalDataChangesService }, { type: i3.ColumnInfoService }]; } });
+        }], ctorParameters: function () { return [{ type: i1.ContextService }, { type: i2.ColumnInfoService }]; } });

package/esm2022/column-menu/column-menu-item.directive.mjs

@@ -12,7 +12,7 @@ import { ContextService } from '../common/provider.service';
 import * as i0 from "@angular/core";
 import * as i1 from "../common/provider.service";
 /**
- * Represents a directive that manages keyboard navigation for a column menu item. [See example](slug:columnmenu_grid#customizing-the-content).
+ * Represents a directive that manages keyboard navigation for a column menu item ([see example](slug:columnmenu_grid#customizing-the-content)).
  *
  * @example
  * ```html

package/esm2022/common/provider.service.mjs

@@ -23,7 +23,7 @@ export class ContextService {
     topToolbarNavigation;
     bottomToolbarNavigation;
     navigable;
-    groupBindingDirective;
+    dataBindingDirective;
     constructor(renderer, localization) {
         this.renderer = renderer;
         this.localization = localization;

package/esm2022/data/data-mapping.service.mjs

@@ -0,0 +1,125 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2025 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable } from '@angular/core';
+import { RowspanService } from '../rendering/rowspan.service';
+import { GroupsService } from '../grouping/groups.service';
+import { DetailsService } from '../rendering/details/details.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../rendering/rowspan.service";
+import * as i2 from "../grouping/groups.service";
+import * as i3 from "../rendering/details/details.service";
+/**
+ * @hidden
+ */
+export class DataMappingService {
+    rowspanService;
+    groupsService;
+    detailsService;
+    recalculateRowspan = true;
+    dataArray = null;
+    constructor(rowspanService, groupsService, detailsService) {
+        this.rowspanService = rowspanService;
+        this.groupsService = groupsService;
+        this.detailsService = detailsService;
+    }
+    isGroup(item) {
+        return item.type === 'group';
+    }
+    /**
+     * Maps the data to the Grid row items, applying rowspan and detail row logic.
+     */
+    dataMapper(data, nonLockedColumnsToRender, lockedLeafColumns, detailTemplate, showFooter) {
+        const result = [];
+        if (!data || !nonLockedColumnsToRender && !lockedLeafColumns) {
+            return [];
+        }
+        let dataIndex = 0;
+        for (const item of data) {
+            if (this.shouldRenderItem(item, detailTemplate, showFooter)) {
+                if (item.type === 'data') {
+                    item.cells = [];
+                    for (let i = 0; i < (lockedLeafColumns.length + nonLockedColumnsToRender.length); i++) {
+                        const column = i < lockedLeafColumns.length ? lockedLeafColumns.get(i) : nonLockedColumnsToRender.get(i - lockedLeafColumns.length);
+                        const cell = {};
+                        if (column.cellRowspan && this.shouldSkipCell(dataIndex, i)) {
+                            cell.skip = true;
+                        }
+                        else {
+                            cell.rowspan = column.cellRowspan ? this.getRowspan({
+                                index: dataIndex,
+                                dataItem: item
+                            }, column, i, data) : 1;
+                        }
+                        item.cells.push(cell);
+                    }
+                }
+                result.push(item);
+            }
+            dataIndex++;
+        }
+        this.recalculateRowspan = true;
+        this.rowspanService.reset();
+        return result;
+    }
+    isDataItem(item) {
+        return !this.isGroup(item) && !this.isFooter(item);
+    }
+    isFooter(item) {
+        return item.type === 'footer';
+    }
+    isFooterItemInExpandedGroup(item) {
+        const footerItem = { data: item.data, index: item.groupIndex, parentGroup: item.group.parentGroup };
+        return this.isInExpandedGroup(footerItem);
+    }
+    isDataItemInExpandedGroup(item) {
+        const dataItem = { data: item.group.data, index: item.groupIndex, parentGroup: item.group.parentGroup };
+        return this.isInExpandedGroup(dataItem);
+    }
+    isInExpandedGroup(item) {
+        return this.groupsService.isInExpandedGroup(item);
+    }
+    isParentGroupExpanded(item) {
+        return this.groupsService.isInExpandedGroup(item.parentGroup);
+    }
+    isExpanded(viewItem) {
+        return this.detailsService.isExpanded(viewItem.index, viewItem.data);
+    }
+    shouldRenderItem(item, detailTemplate, showFooter) {
+        const renderGroupHeader = this.isGroup(item) && this.isParentGroupExpanded(item);
+        const renderDataItem = this.isDataItem(item) && (!item.group || this.isDataItemInExpandedGroup(item));
+        const renderDetailTemplate = renderDataItem && detailTemplate?.templateRef && detailTemplate.showIf(item.data, item.index) && this.isExpanded(item);
+        const isVisibleFooter = this.isFooter(item) && item.group && (this.isFooterItemInExpandedGroup(item) || (showFooter && this.isParentGroupExpanded(item.group)));
+        const renderFooter = isVisibleFooter && !item.data.hideFooter;
+        item.showDataItem = renderDataItem;
+        item.showDetailRow = renderDataItem && renderDetailTemplate;
+        item.isExpanded = this.isExpanded(item);
+        return renderGroupHeader || renderDataItem || renderDetailTemplate || renderFooter;
+    }
+    shouldSkipCell(rowIndex, colIndex) {
+        return this.rowspanService.shouldSkip(rowIndex, colIndex);
+    }
+    cachedDataArray(data) {
+        if (!this.dataArray) {
+            this.dataArray = data.map(item => item);
+        }
+        return this.dataArray;
+    }
+    getRowspan(row, column, colIndex, data) {
+        if (this.recalculateRowspan) {
+            this.dataArray = null;
+            this.recalculateRowspan = false;
+        }
+        const rowspan = column.cellRowspan(row, column, this.cachedDataArray(data));
+        if (rowspan > 1) {
+            this.rowspanService.addCells(row.index, colIndex, rowspan);
+        }
+        return rowspan;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DataMappingService, deps: [{ token: i1.RowspanService }, { token: i2.GroupsService }, { token: i3.DetailsService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DataMappingService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DataMappingService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.RowspanService }, { type: i2.GroupsService }, { type: i3.DetailsService }]; } });

package/esm2022/databinding.directive.mjs

@@ -8,10 +8,12 @@ import { GridComponent } from './grid.component';
 import { anyChanged, isPresent } from './utils';
 import { LocalDataChangesService } from './editing/local-data-changes.service';
 import { RowReorderService } from './row-reordering/row-reorder.service';
+import { ContextService } from './common/provider.service';
 import * as i0 from "@angular/core";
 import * as i1 from "./grid.component";
 import * as i2 from "./editing/local-data-changes.service";
 import * as i3 from "./row-reordering/row-reorder.service";
+import * as i4 from "./common/provider.service";
 /**
  * A directive that handles in-memory data operations like [paging]({% slug paging_grid %}),
  * [sorting]({% slug sorting_grid %}), and [grouping]({% slug grouping_grid %}).
@@ -92,7 +94,7 @@ export class DataBindingDirective {
     stateChangeSubscription;
     dataChangedSubscription;
     rowReorderSubscription;
-    constructor(grid, changeDetector, localDataChangesService, rowReorderService) {
+    constructor(grid, changeDetector, localDataChangesService, rowReorderService, ctx) {
         this.grid = grid;
         this.changeDetector = changeDetector;
         this.localDataChangesService = localDataChangesService;
@@ -100,6 +102,7 @@ export class DataBindingDirective {
         if (localDataChangesService) {
             this.dataChangedSubscription = this.localDataChangesService.changes.subscribe(this.rebind.bind(this));
         }
+        ctx && (ctx.dataBindingDirective = this);
     }
     /**
      * @hidden
@@ -174,6 +177,12 @@ export class DataBindingDirective {
         }
     }
     process(state) {
+        if (this.grid.isVirtual && (!isPresent(state.take) || state.take === 0)) {
+            return {
+                data: [],
+                total: this.originalData?.length || 0
+            };
+        }
         return process(this.originalData, state);
     }
     applyState({ skip, take, sort, group, filter }) {
@@ -188,7 +197,7 @@ export class DataBindingDirective {
         this.grid.updateNavigationMetadata();
         this.dataChanged = false;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DataBindingDirective, deps: [{ token: i1.GridComponent }, { token: i0.ChangeDetectorRef }, { token: i2.LocalDataChangesService }, { token: i3.RowReorderService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DataBindingDirective, deps: [{ token: i1.GridComponent }, { token: i0.ChangeDetectorRef }, { token: i2.LocalDataChangesService }, { token: i3.RowReorderService }, { token: i4.ContextService }], target: i0.ɵɵFactoryTarget.Directive });
     static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: DataBindingDirective, isStandalone: true, selector: "[kendoGridBinding]", inputs: { skip: "skip", sort: "sort", filter: "filter", pageSize: "pageSize", group: "group", data: ["kendoGridBinding", "data"] }, exportAs: ["kendoGridBinding"], usesOnChanges: true, ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DataBindingDirective, decorators: [{
@@ -198,7 +207,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                     exportAs: 'kendoGridBinding',
                     standalone: true
                 }]
-        }], ctorParameters: function () { return [{ type: i1.GridComponent }, { type: i0.ChangeDetectorRef }, { type: i2.LocalDataChangesService }, { type: i3.RowReorderService }]; }, propDecorators: { skip: [{
+        }], ctorParameters: function () { return [{ type: i1.GridComponent }, { type: i0.ChangeDetectorRef }, { type: i2.LocalDataChangesService }, { type: i3.RowReorderService }, { type: i4.ContextService }]; }, propDecorators: { skip: [{
                 type: Input
             }], sort: [{
                 type: Input