@progress/kendo-angular-grid 21.4.1 → 22.0.0

package/esm2022/column-resizing/column-resizing.service.mjs

@@ -1,214 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Injectable, EventEmitter } from '@angular/core';
-import { zip } from 'rxjs';
-import { take } from 'rxjs/operators';
-import { leafColumns } from '../columns/column-common';
-import * as i0 from "@angular/core";
-/**
- * @hidden
- */
-const isLocked = column => column.parent ? isLocked(column.parent) : !!column.locked;
-/**
- * @hidden
- */
-const resizeArgs = (column, extra) => Object.assign({
-    columns: leafColumns([column]),
-    locked: isLocked(column)
-}, extra);
-/**
- * @hidden
- */
-const measure = (col, gridEl) => {
-    const rowIndex = col.level + 1;
-    const selector = `tr[aria-rowindex="${rowIndex}"] > th[aria-colindex="${col.leafIndex + 1}"], tr[aria-rowindex="${rowIndex}"] > th[data-kendo-grid-column-index="${col.leafIndex}"]`;
-    const headerCell = gridEl.querySelector(selector);
-    if (headerCell) {
-        const headerCellWidth = headerCell.offsetWidth;
-        if (headerCellWidth > 0) {
-            return headerCellWidth;
-        }
-    }
-    return 0;
-};
-/**
- * @hidden
- */
-export class ColumnResizingService {
-    changes = new EventEmitter();
-    adjacentColumn;
-    areColumnsReordered = false;
-    isShiftPressed = false;
-    originalWidth;
-    draggedGroupColumn;
-    resizedColumns;
-    autoFitResize = false;
-    column;
-    tables = [];
-    batch = null;
-    start(column) {
-        this.trackColumns(column);
-        const columns = (this.column.isColumnGroup ? [column] : [])
-            .concat(leafColumns([column]));
-        this.changes.emit({
-            columns: columns,
-            locked: isLocked(this.column),
-            type: 'start'
-        });
-    }
-    resizeColumns(deltaPercent) {
-        const action = resizeArgs(this.column, {
-            deltaPercent,
-            type: 'resizeColumn'
-        });
-        this.changes.emit(action);
-    }
-    resizeTable(column, delta) {
-        const action = resizeArgs(column, {
-            delta,
-            type: 'resizeTable'
-        });
-        this.changes.emit(action);
-    }
-    resizedColumn(state) {
-        this.resizedColumns.push(state);
-    }
-    end() {
-        this.changes.emit({
-            columns: [],
-            resizedColumns: this.resizedColumns,
-            type: 'end'
-        });
-        this.restoreInitialMaxMinWidths();
-        this.adjacentColumn = null;
-        this.draggedGroupColumn = null;
-        this.autoFitResize = false;
-    }
-    registerTable(tableMetadata) {
-        this.tables.push(tableMetadata);
-        const unregisterTable = () => {
-            this.tables.splice(this.tables.indexOf(tableMetadata), 1);
-        };
-        return unregisterTable;
-    }
-    measureColumns(info) {
-        if (this.batch !== null) {
-            this.batch.push(...info);
-        }
-        else {
-            this.autoFitBatch(info, () => this.end());
-        }
-    }
-    autoFit(...columns) {
-        const nonLockedColumns = columns.filter(column => !column.isLocked);
-        this.autoFitStart(nonLockedColumns);
-        this.autoFitBatch(this.batch, () => {
-            if (nonLockedColumns.length < columns.length) {
-                const lockedColumns = columns.filter(column => column.isLocked);
-                this.autoFitStart(lockedColumns);
-                this.autoFitBatch(this.batch, () => this.end());
-            }
-            else {
-                this.end();
-            }
-        });
-    }
-    autoFitToGrid(gridEl, scrollbarWidth, ...columns) {
-        const gridWidth = gridEl.clientWidth - scrollbarWidth - 1;
-        if (gridWidth <= 0) {
-            return;
-        }
-        const columnsWidths = columns.map(c => measure(c, gridEl));
-        const totalColumnsWidth = columnsWidths.reduce((sum, w) => sum + w, 0);
-        if (totalColumnsWidth === 0 || Math.abs(totalColumnsWidth - gridWidth) <= 1) {
-            return;
-        }
-        this.start(columns[0]);
-        const calculateNewWidths = (columnsWidths) => {
-            const totalWidth = columnsWidths.reduce((s, w) => s + w, 0);
-            const nonZeroColumns = columnsWidths.filter(w => w > 0).length;
-            const diff = (gridWidth - totalWidth) / nonZeroColumns;
-            const newWidths = columnsWidths.slice();
-            newWidths.forEach((w, i) => {
-                newWidths[i] = Math.max(0, w + diff);
-            });
-            return newWidths;
-        };
-        let newWidths = calculateNewWidths(columnsWidths);
-        const newTotal = newWidths.reduce((s, w) => s + w, 0);
-        if (newTotal !== gridWidth) {
-            newWidths = calculateNewWidths(newWidths);
-        }
-        columns.forEach((col, idx) => {
-            const oldWidth = columnsWidths[idx];
-            const newWidth = newWidths[idx];
-            col.width = newWidth;
-            this.resizedColumn({ column: col, oldWidth, newWidth });
-        });
-        const totalNew = newWidths.reduce((s, w) => s + w, 0);
-        const tableDelta = totalNew - totalColumnsWidth;
-        if (tableDelta < 0) {
-            this.resizeTable(columns[0], tableDelta);
-        }
-        this.end();
-    }
-    trackColumns(column) {
-        this.resizedColumns = [];
-        this.column = column;
-    }
-    autoFitStart(columns) {
-        this.batch = [];
-        this.resizedColumns = [];
-        if (columns.length === 0) {
-            return;
-        }
-        const locked = columns[0].isLocked;
-        this.changes.emit({
-            type: 'start',
-            columns,
-            locked
-        });
-        this.changes.emit({
-            type: 'triggerAutoFit',
-            columns,
-            locked
-        });
-    }
-    autoFitBatch(info, onComplete) {
-        const locked = info.length > 0 ? info[0].column.isLocked : false;
-        const observables = this.tables
-            .filter(table => table.locked === locked)
-            .map(table => table.autoFit(info));
-        zip(...observables)
-            .pipe(take(1))
-            .subscribe(widths => {
-            this.changes.emit({
-                columns: info.map(i => i.column),
-                type: 'autoFitComplete',
-                widths,
-                locked
-            });
-            if (onComplete) {
-                onComplete();
-            }
-        });
-        this.batch = null;
-    }
-    restoreInitialMaxMinWidths() {
-        if (this.adjacentColumn) {
-            this.adjacentColumn.maxResizableWidth = this.adjacentColumn.initialMaxResizableWidth;
-            this.adjacentColumn.minResizableWidth = this.adjacentColumn.initialMinResizableWidth;
-        }
-        if (this.column) {
-            this.column.maxResizableWidth = this.column.initialMaxResizableWidth;
-            this.column.minResizableWidth = this.column.initialMinResizableWidth;
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ColumnResizingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ColumnResizingService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ColumnResizingService, decorators: [{
-            type: Injectable
-        }] });

package/esm2022/column-resizing/table.directive.mjs

@@ -1,141 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { ChangeDetectorRef, Directive, ElementRef, HostBinding, Input, NgZone, Renderer2 } from '@angular/core';
-import { Observable } from 'rxjs';
-import { resizableColumns } from '../columns/column-common';
-import { ColumnResizingService } from './column-resizing.service';
-import { filter, tap, map, switchMap, bufferCount } from 'rxjs/operators';
-import { ContextService } from '../common/provider.service';
-import * as i0 from "@angular/core";
-import * as i1 from "./column-resizing.service";
-import * as i2 from "../common/provider.service";
-/**
- * @hidden
- */
-const columnsToResize = ({ columns }) => Math.max(1, resizableColumns(columns).filter(c => !c.isColumnGroup).length);
-/**
- * @hidden
- */
-const row = selector => element => element.querySelector(selector);
-/**
- * @hidden
- */
-const headerRow = index => element => element.querySelectorAll('thead>tr')[index];
-/**
- * @hidden
- */
-const cell = (index, selector = 'td') => element => element.querySelectorAll(`${selector}:not(.k-group-cell):not(.k-hierarchy-cell)`)[index];
-/**
- * @hidden
- */
-const offsetWidth = element => element.offsetWidth;
-/**
- * @hidden
- */
-const pipe = (...fns) => data => fns.reduce((state, fn) => state ? fn(state) : 0, data);
-/**
- * @hidden
- */
-export class TableDirective {
-    element;
-    renderer;
-    service;
-    zone;
-    cdr;
-    ctx;
-    locked = false;
-    virtualColumns;
-    get minWidth() {
-        return this.firstResize ? 0 : null;
-    }
-    firstResize = false;
-    subscription;
-    autoFitSubscription;
-    constructor(element, renderer, service, zone, cdr, ctx) {
-        this.element = element;
-        this.renderer = renderer;
-        this.service = service;
-        this.zone = zone;
-        this.cdr = cdr;
-        this.ctx = ctx;
-    }
-    ngOnInit() {
-        const obs = this.service
-            .changes.pipe(filter(e => this.locked === e.locked));
-        this.subscription = obs.pipe(filter(e => e.type === 'start'), tap(this.initState.bind(this)), map(columnsToResize), switchMap((take) => obs.pipe(filter(e => e.type === 'resizeTable'), map(e => e.delta), bufferCount(take)))).subscribe(this.resize.bind(this));
-        this.autoFitSubscription = this.service
-            .registerTable({
-            autoFit: this.autoFitObservable.bind(this),
-            locked: this.locked
-        });
-    }
-    ngOnDestroy() {
-        if (this.subscription) {
-            this.subscription.unsubscribe();
-        }
-        if (this.autoFitSubscription) {
-            this.autoFitSubscription();
-            this.autoFitSubscription = null;
-        }
-    }
-    initState() {
-        this.firstResize = true;
-        const constrainedWithVirtualColumns = this.ctx.grid?.resizable === 'constrained' && this.virtualColumns;
-        if ((!this.virtualColumns || this.locked) || constrainedWithVirtualColumns) {
-            this.service.originalWidth = offsetWidth(this.element.nativeElement);
-        }
-    }
-    resize(deltas) {
-        const constrainedModeNoShift = this.ctx.grid?.resizable === 'constrained' && !this.service.isShiftPressed;
-        const unconstrainedModeShift = (this.ctx.grid?.resizable === true || this.ctx.grid?.resizable === 'unconstrained') && this.service.isShiftPressed;
-        const isConstrainedMode = constrainedModeNoShift || unconstrainedModeShift;
-        if (isConstrainedMode && !this.service.autoFitResize) {
-            this.renderer.setStyle(this.element.nativeElement, 'width', this.service.originalWidth + 'px');
-        }
-        else if (!this.virtualColumns || this.locked) {
-            const delta = deltas.reduce((sum, item) => sum + item, 0);
-            const width = this.service.originalWidth + delta;
-            this.renderer.setStyle(this.element.nativeElement, 'width', width + 'px');
-        }
-        this.cdr.detectChanges();
-    }
-    autoFitObservable(columnInfo) {
-        return Observable.create(observer => {
-            this.zone.runOutsideAngular(() => {
-                this.renderer.addClass(this.element.nativeElement, 'k-autofitting');
-                this.cdr.detectChanges();
-                const widths = columnInfo.map(this.measureColumn.bind(this));
-                this.renderer.removeClass(this.element.nativeElement, 'k-autofitting');
-                observer.next(widths);
-            });
-        });
-    }
-    measureColumn(info) {
-        const dom = this.element.nativeElement;
-        const header = pipe(headerRow(info.level), cell(info.headerIndex, 'th'), offsetWidth)(dom);
-        let data = 0;
-        if (!info.isParentSpan || (info.isParentSpan && info.isLastInSpan)) {
-            data = pipe(row('tbody>tr:not(.k-grouping-row):not(.k-grid-norecords)'), cell(info.index), offsetWidth)(dom);
-        }
-        const footer = pipe(row('tfoot>tr'), cell(info.index), offsetWidth)(dom);
-        return Math.max(header, data, footer);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.ColumnResizingService }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }, { token: i2.ContextService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: TableDirective, isStandalone: true, selector: "[kendoGridResizableTable]", inputs: { locked: "locked", virtualColumns: "virtualColumns" }, host: { properties: { "style.min-width": "this.minWidth" } }, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TableDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[kendoGridResizableTable]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.ColumnResizingService }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: i2.ContextService }], propDecorators: { locked: [{
-                type: Input
-            }], virtualColumns: [{
-                type: Input
-            }], minWidth: [{
-                type: HostBinding,
-                args: ['style.min-width']
-            }] } });

package/esm2022/columns/cell-rowspan.mjs

@@ -1,5 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-export {};

package/esm2022/columns/checkbox-column.component.mjs

@@ -1,106 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Component, forwardRef, ContentChild, SkipSelf, Host, Optional, Input } from '@angular/core';
-import { ColumnBase } from './column-base';
-import { CellTemplateDirective } from '../rendering/cell-template.directive';
-import { IdService } from '../common/id.service';
-import { SelectionService } from '../selection/selection.service';
-import { CellSelectionService } from '../selection/cell-selection.service';
-import * as i0 from "@angular/core";
-import * as i1 from "../selection/selection.service";
-import * as i2 from "../selection/cell-selection.service";
-import * as i3 from "./column-base";
-import * as i4 from "../common/id.service";
-/**
- * Represents the checkbox column for selecting rows in the Grid. [See example](slug:grid_row_selection#toc-select-all-checkbox).
- *
- * Use this column to add checkboxes for row selection.
- *
- * @example
- * ```html
- * <kendo-grid [selectable]="{enabled: true, checkboxOnly: true}">
- *   <kendo-grid-checkbox-column title="Select"></kendo-grid-checkbox-column>
- *   <kendo-grid-column field="ID"></kendo-grid-column>
- * </kendo-grid>
- * ```
- */
-export class CheckboxColumnComponent extends ColumnBase {
-    selectionService;
-    cellSelectionService;
-    parent;
-    /**
-     * Shows a select-all `kendoGridSelectAllCheckbox` checkbox in the header.
-     */
-    showSelectAll;
-    /**
-     * Shows checkboxes for rows marked as non-selectable. By default, these checkboxes are visible and disabled.
-     */
-    showDisabledCheckbox = true;
-    /*
-     * @hidden
-     */
-    isCheckboxColumn = true;
-    template;
-    constructor(selectionService, cellSelectionService, parent, idService) {
-        super(parent, idService);
-        this.selectionService = selectionService;
-        this.cellSelectionService = cellSelectionService;
-        this.parent = parent;
-    }
-    get templateRef() {
-        return this.template ? this.template.templateRef : undefined;
-    }
-    /**
-     * @hidden
-     */
-    rowSelectable(rowIdx) {
-        return !this.selectionService.nonSelectableRows.has(rowIdx) && !this.cellSelectionService.nonSelectableRows.has(rowIdx);
-    }
-    /**
-     * Defines a function to determine the rowspan of each column cell.
-     */
-    set cellRowspan(cellRowspan) {
-        super.cellRowspan = cellRowspan;
-    }
-    get cellRowspan() {
-        return super.cellRowspan;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CheckboxColumnComponent, deps: [{ token: i1.SelectionService }, { token: i2.CellSelectionService }, { token: i3.ColumnBase, host: true, optional: true, skipSelf: true }, { token: i4.IdService, optional: true }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: CheckboxColumnComponent, isStandalone: true, selector: "kendo-grid-checkbox-column", inputs: { showSelectAll: "showSelectAll", showDisabledCheckbox: "showDisabledCheckbox" }, providers: [
-            {
-                provide: ColumnBase,
-                useExisting: forwardRef(() => CheckboxColumnComponent)
-            }
-        ], queries: [{ propertyName: "template", first: true, predicate: CellTemplateDirective, descendants: true }], usesInheritance: true, ngImport: i0, template: ``, isInline: true });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CheckboxColumnComponent, decorators: [{
-            type: Component,
-            args: [{
-                    providers: [
-                        {
-                            provide: ColumnBase,
-                            useExisting: forwardRef(() => CheckboxColumnComponent)
-                        }
-                    ],
-                    selector: 'kendo-grid-checkbox-column',
-                    template: ``,
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i1.SelectionService }, { type: i2.CellSelectionService }, { type: i3.ColumnBase, decorators: [{
-                    type: SkipSelf
-                }, {
-                    type: Host
-                }, {
-                    type: Optional
-                }] }, { type: i4.IdService, decorators: [{
-                    type: Optional
-                }] }], propDecorators: { showSelectAll: [{
-                type: Input
-            }], showDisabledCheckbox: [{
-                type: Input
-            }], template: [{
-                type: ContentChild,
-                args: [CellTemplateDirective, { static: false }]
-            }] } });