@progress/kendo-angular-grid 18.1.0-develop.3 → 18.1.0-develop.31

package/column-resizing/column-handle.directive.d.ts

@@ -29,6 +29,10 @@ export declare class ColumnHandleDirective implements OnInit, OnDestroy {
     private get isConstrainedMode();
     private subscriptions;
     private rtl;
+    private totalChildrenSum;
+    private childrenColumns;
+    private minWidthTotal;
+    private foundColumn;
     autoFit(): void;
     constructor(draggable: DraggableDirective, element: ElementRef, service: ColumnResizingService, zone: NgZone, cdr: ChangeDetectorRef, ctx: ContextService, columnInfoService: ColumnInfoService);
     ngOnInit(): void;
@@ -39,9 +43,18 @@ export declare class ColumnHandleDirective implements OnInit, OnDestroy {
     private resize;
     private sizeToFit;
     private updateWidth;
+    private updateWidthsOfResizedColumns;
+    private calcNewColumnWidth;
+    private setAdjacentColumn;
+    private firstGroupChild;
+    private setGroupWidths;
+    private updateWidthOfDraggedColumn;
+    private calcChildrenWidth;
     private columnsForLevel;
+    private minAdjacentColumnWidth;
     private getTableDelta;
     private stopPropagation;
+    private isLastInGroup;
     static ɵfac: i0.ɵɵFactoryDeclaration<ColumnHandleDirective, [{ host: true; }, null, null, null, null, null, null]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ColumnHandleDirective, "[kendoGridColumnHandle]", never, { "isLast": { "alias": "isLast"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "column": { "alias": "column"; "required": false; }; }, {}, never, never, true, never>;
 }

package/column-resizing/column-resizing.service.d.ts

@@ -5,6 +5,7 @@
 import { EventEmitter } from '@angular/core';
 import { ColumnBase } from '../columns/column-base';
 import { ColumnResizeAction, ColumnResizeArgs, AutoFitFn } from './column-resize.interface';
+import { ColumnGroupComponent } from '../columns/column-group.component';
 import * as i0 from "@angular/core";
 /**
  * @hidden
@@ -15,8 +16,10 @@ export declare class ColumnResizingService {
     areColumnsReordered: boolean;
     isShiftPressed: boolean;
     originalWidth: number;
+    draggedGroupColumn: ColumnGroupComponent;
+    resizedColumns: Array<ColumnResizeArgs>;
+    autoFitResize: boolean;
     private column;
-    private resizedColumns;
     private tables;
     private batch;
     start(column: ColumnBase): void;
@@ -33,6 +36,7 @@ export declare class ColumnResizingService {
     private trackColumns;
     private autoFitStart;
     private autoFitBatch;
+    private restoreInitialMaxMinWidths;
     static ɵfac: i0.ɵɵFactoryDeclaration<ColumnResizingService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ColumnResizingService>;
 }

package/columns/column-base.d.ts

@@ -26,6 +26,18 @@ export declare const isRowReorderColumn: (column: any) => any;
  */
 export declare class ColumnBase {
     parent?: ColumnBase;
+    /**
+     * @hidden
+     */
+    isReordered: boolean;
+    /**
+     * @hidden
+     */
+    initialMaxResizableWidth: number;
+    /**
+     * @hidden
+     */
+    initialMinResizableWidth: number;
     /**
      * @hidden
      */

package/columns/column.component.d.ts

@@ -2,7 +2,7 @@
 * Copyright © 2025 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-import { TemplateRef } from '@angular/core';
+import { TemplateRef, AfterViewInit } from '@angular/core';
 import { CellTemplateDirective } from '../rendering/cell-template.directive';
 import { GroupHeaderTemplateDirective } from '../grouping/group-header-template.directive';
 import { GroupHeaderColumnTemplateDirective } from '../grouping/group-header-column-template.directive';
@@ -30,7 +30,7 @@ export declare function isColumnComponent(column: any): column is ColumnComponen
  * </kendo-grid>
  * ```
  */
-export declare class ColumnComponent extends ColumnBase {
+export declare class ColumnComponent extends ColumnBase implements AfterViewInit {
     /**
      * The field to which the column is bound.
      */
@@ -94,6 +94,7 @@ export declare class ColumnComponent extends ColumnBase {
     get filterCellTemplateRef(): TemplateRef<any>;
     get filterMenuTemplateRef(): TemplateRef<any>;
     get displayTitle(): string;
+    ngAfterViewInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ColumnComponent, [{ optional: true; host: true; skipSelf: true; }, { optional: true; }]>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ColumnComponent, "kendo-grid-column", never, { "field": { "alias": "field"; "required": false; }; "format": { "alias": "format"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "groupable": { "alias": "groupable"; "required": false; }; "editor": { "alias": "editor"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; }, {}, ["template", "groupHeaderTemplate", "groupHeaderColumnTemplate", "groupFooterTemplate", "editTemplate", "filterCellTemplate", "filterMenuTemplate"], never, true, never>;
 }

package/common/resizable-settings.d.ts

@@ -0,0 +1,25 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2025 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * The size restrictions that will be applied to the resizable Grid.
+ */
+export interface GridResizableSettings {
+    /**
+     * Specifies the maximum width of the resizable Grid. Accepts all applicable string values for [`max-width`](https://developer.mozilla.org/en-US/docs/Web/CSS/max-width).
+     */
+    maxWidth?: string;
+    /**
+     * Specifies the maximum height of the resizable Grid. Accepts all applicable string values for [`max-height`](https://developer.mozilla.org/en-US/docs/Web/CSS/max-height).
+     */
+    maxHeight?: string;
+    /**
+     * Specifies the minimum width of the resizable Grid. Accepts all applicable string values for [`min-width`](https://developer.mozilla.org/en-US/docs/Web/CSS/min-width).
+     */
+    minWidth?: string;
+    /**
+     * Specifies the minimum height of the resizable Grid. Accepts all applicable string values for [`min-height`](https://developer.mozilla.org/en-US/docs/Web/CSS/min-height).
+     */
+    minHeight?: string;
+}

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

@@ -31,11 +31,20 @@ const toPercentage = (value, whole) => (value / whole) * 100;
 /**
  * @hidden
  */
-const headerWidth = (handle) => handle.nativeElement.parentElement.offsetWidth;
+const headerWidth = (handle) => handle.nativeElement.parentElement.getBoundingClientRect().width;
 /**
  * @hidden
  */
-const adjacentColumnWidth = (handle) => handle.nativeElement.parentElement.nextElementSibling?.offsetWidth;
+const adjacentColumnWidth = (handle) => handle.nativeElement.parentElement.nextElementSibling?.getBoundingClientRect().width;
+/**
+ * @hidden
+ */
+const adjacentColumnInGroupWidth = (handle, rowIndex, colIndex) => {
+    const tableElement = handle.nativeElement.closest('.k-grid-header-table');
+    const selector = (rowAttribute) => `tr[${rowAttribute}="${rowIndex}"] th[aria-colindex="${colIndex}"]`;
+    const thElement = tableElement.querySelector([selector('aria-rowindex'), selector('data-kendo-grid-row-index')]);
+    return thElement.getBoundingClientRect().width;
+};
 /**
  * @hidden
  */
@@ -95,7 +104,7 @@ export class ColumnHandleDirective {
     columns = [];
     column;
     get visible() {
-        if (this.isConstrainedMode && this.isLast) {
+        if (this.isConstrainedMode && (this.isLast || this.isLastInGroup(this.column))) {
             return 'none';
         }
         return this.column.resizable ? 'block' : 'none';
@@ -115,7 +124,12 @@ export class ColumnHandleDirective {
     }
     subscriptions = new Subscription();
     rtl = false;
+    totalChildrenSum = 0;
+    childrenColumns = [];
+    minWidthTotal = 0;
+    foundColumn;
     autoFit() {
+        this.service.autoFitResize = true;
         const allLeafs = allLeafColumns(this.columns);
         const currentLeafs = leafColumns([this.column]).filter(column => isTruthy(column.resizable));
         const columnInfo = currentLeafs.map(column => {
@@ -173,35 +187,19 @@ export class ColumnHandleDirective {
     }
     shouldUpdate() {
         return !allLeafColumns(this.columns)
-            .map(column => column.width)
+            .map(column => column.width || (this.isConstrainedMode && !column.width && column.implicitWidth))
             .some(isBlank);
     }
     initColumnWidth() {
         this.column.width = headerWidth(this.element);
+        if (this.isConstrainedMode) {
+            this.column.resizeStartWidth = this.column.width;
+        }
     }
     initState() {
         this.column.resizeStartWidth = headerWidth(this.element);
-        let columns = [];
-        if (this.ctx.grid?.columns) {
-            columns = Array.from(this.ctx.grid?.columns) || [];
-        }
-        if (this.isConstrainedMode) {
-            if (this.service.areColumnsReordered) {
-                this.service.adjacentColumn = columns.find(c => c.orderIndex === this.column.orderIndex + 1);
-                this.service.adjacentColumn.resizeStartWidth = adjacentColumnWidth(this.element);
-                this.service.resizedColumn({
-                    column: this.service.adjacentColumn,
-                    oldWidth: this.service.adjacentColumn.resizeStartWidth
-                });
-            }
-            else {
-                this.service.adjacentColumn = columns[this.column.leafIndex + 1];
-                this.service.adjacentColumn.resizeStartWidth = adjacentColumnWidth(this.element);
-                this.service.resizedColumn({
-                    column: this.service.adjacentColumn,
-                    oldWidth: this.service.adjacentColumn.resizeStartWidth
-                });
-            }
+        if (this.isConstrainedMode && !this.service.adjacentColumn) {
+            this.setAdjacentColumn();
         }
         this.service.resizedColumn({
             column: this.column,
@@ -218,12 +216,7 @@ export class ColumnHandleDirective {
             newWidth = Math.min(newWidth, this.column.maxResizableWidth);
         }
         if (this.isConstrainedMode) {
-            const maxAllowedResizableWidth = this.column.resizeStartWidth + this.service.adjacentColumn.resizeStartWidth - this.service.adjacentColumn.minResizableWidth;
-            newWidth = Math.min(newWidth, maxAllowedResizableWidth);
-        }
-        if (this.isConstrainedMode && isPresent(this.service.adjacentColumn.maxResizableWidth)) {
-            const maxAllowedResizableWidth = this.column.resizeStartWidth + this.service.adjacentColumn.resizeStartWidth - this.service.adjacentColumn.maxResizableWidth;
-            newWidth = Math.max(newWidth, maxAllowedResizableWidth);
+            newWidth = this.calcNewColumnWidth(newWidth);
         }
         const tableDelta = this.getTableDelta(newWidth, delta);
         this.updateWidth(this.column, newWidth);
@@ -237,11 +230,8 @@ export class ColumnHandleDirective {
         this.service.resizeTable(this.column, tableDelta);
     }
     updateWidth(column, width) {
-        if (this.isConstrainedMode && this.service.adjacentColumn) {
-            const adjacentColumnNewWidth = column.resizeStartWidth + this.service.adjacentColumn.resizeStartWidth - width;
-            if (adjacentColumnNewWidth < (column.resizeStartWidth + this.service.adjacentColumn.resizeStartWidth)) {
-                this.service.adjacentColumn.width = adjacentColumnNewWidth;
-            }
+        if (this.isConstrainedMode && this.service.adjacentColumn && !this.service.autoFitResize) {
+            this.updateWidthsOfResizedColumns(column, width);
         }
         column.width = width;
         this.columnInfoService.hiddenColumns.forEach((col) => {
@@ -253,9 +243,188 @@ export class ColumnHandleDirective {
         });
         this.cdr.markForCheck(); //force CD cycle
     }
+    updateWidthsOfResizedColumns(column, width) {
+        let adjacentColumnNewWidth = column.resizeStartWidth + this.service.adjacentColumn.resizeStartWidth - width;
+        if (this.service.draggedGroupColumn && column.parent) {
+            this.updateWidthOfDraggedColumn(column, width);
+            this.setGroupWidths(this.service.draggedGroupColumn);
+        }
+        else if (!this.service.draggedGroupColumn && !column.parent && this.service.adjacentColumn.parent) {
+            this.service.adjacentColumn.parent.width = column.width + this.service.adjacentColumn.parent.width - width;
+            this.service.adjacentColumn.width = adjacentColumnNewWidth;
+        }
+        else if (!this.service.draggedGroupColumn && column.parent && this.service.adjacentColumn.parent) {
+            adjacentColumnNewWidth = column.width + this.service.adjacentColumn.width - width;
+            this.service.adjacentColumn.width = adjacentColumnNewWidth;
+            const filteredColumns = this.service.adjacentColumn.parent.children.filter(c => c !== this.service.adjacentColumn);
+            const filteredColumnsWidth = filteredColumns.reduce((acc, c) => acc + c.width, 0);
+            this.service.adjacentColumn.parent.width = adjacentColumnNewWidth + filteredColumnsWidth;
+            this.setGroupWidths(this.service.adjacentColumn.parent);
+        }
+        else if (adjacentColumnNewWidth > this.service.adjacentColumn.minResizableWidth) {
+            this.service.adjacentColumn.width = adjacentColumnNewWidth;
+        }
+    }
+    calcNewColumnWidth(newWidth) {
+        let maxAllowedResizableWidth;
+        if (!this.service.adjacentColumn.parent) {
+            maxAllowedResizableWidth = this.column.width + this.service.adjacentColumn.width - this.service.adjacentColumn.minResizableWidth;
+            if (!this.column.parent) {
+                maxAllowedResizableWidth = this.column.resizeStartWidth + this.service.adjacentColumn.resizeStartWidth - this.service.adjacentColumn.minResizableWidth;
+                if (this.service.adjacentColumn.maxResizableWidth) {
+                    const minResizableWidth = this.column.resizeStartWidth + this.service.adjacentColumn.resizeStartWidth - this.service.adjacentColumn.maxResizableWidth;
+                    maxAllowedResizableWidth = this.column.resizeStartWidth + this.service.adjacentColumn.resizeStartWidth - this.service.adjacentColumn.minResizableWidth;
+                    this.column.minResizableWidth = minResizableWidth;
+                    this.column.maxResizableWidth = maxAllowedResizableWidth;
+                }
+            }
+        }
+        else {
+            maxAllowedResizableWidth = this.column.width + this.service.adjacentColumn.width;
+            newWidth = Math.min(newWidth, maxAllowedResizableWidth);
+            this.minWidthTotal = 0;
+            const minResizableWidth = this.minAdjacentColumnWidth(this.service.adjacentColumn);
+            maxAllowedResizableWidth -= minResizableWidth;
+        }
+        return Math.min(newWidth, maxAllowedResizableWidth - 1);
+    }
+    setAdjacentColumn() {
+        const columnsForLevel = this.columnsForLevel(this.column.level);
+        if (this.column.parent) {
+            if (this.column.isReordered) {
+                this.service.adjacentColumn = columnsForLevel.find(c => c.orderIndex === this.column.orderIndex + 1);
+                this.service.adjacentColumn.resizeStartWidth = this.service.adjacentColumn.width;
+            }
+            else {
+                const columnIndex = columnsForLevel.indexOf(this.column);
+                this.service.adjacentColumn = columnsForLevel[columnIndex + 1];
+                this.service.adjacentColumn.resizeStartWidth = adjacentColumnWidth(this.element);
+                const parentColumnChildren = Array.from(this.column.parent.children);
+                const indexOfCurrentColumn = parentColumnChildren.indexOf(this.column);
+                let adjacentColumn;
+                if (indexOfCurrentColumn + 1 <= parentColumnChildren.length - 1) {
+                    adjacentColumn = parentColumnChildren[indexOfCurrentColumn + 1];
+                    if (adjacentColumn?.isColumnGroup) {
+                        this.service.adjacentColumn = adjacentColumn;
+                    }
+                }
+            }
+            if (this.service.adjacentColumn.isColumnGroup) {
+                this.foundColumn = null;
+                this.service.adjacentColumn = this.firstGroupChild(this.service.adjacentColumn);
+            }
+            if (this.column.isColumnGroup) {
+                this.service.draggedGroupColumn = this.column;
+            }
+        }
+        else if (this.column.isColumnGroup) {
+            if (this.column.isReordered) {
+                this.service.adjacentColumn = columnsForLevel.find(c => c.orderIndex === this.column.orderIndex + 1);
+            }
+            else {
+                this.service.adjacentColumn = columnsForLevel[columnsForLevel.indexOf(this.column) + 1];
+            }
+            this.service.adjacentColumn.resizeStartWidth = adjacentColumnWidth(this.element);
+            if (this.service.adjacentColumn.isColumnGroup) {
+                this.foundColumn = null;
+                this.service.adjacentColumn = this.firstGroupChild(this.service.adjacentColumn);
+            }
+            this.service.adjacentColumn.resizeStartWidth = this.service.adjacentColumn.width;
+            this.service.draggedGroupColumn = this.column;
+        }
+        else {
+            if (this.column.isReordered) {
+                this.service.adjacentColumn = columnsForLevel.find(col => col.orderIndex === this.column.orderIndex + 1);
+            }
+            else {
+                let adjacentColumn = columnsForLevel.find(c => c.leafIndex === this.column.leafIndex + 1);
+                if (!adjacentColumn) {
+                    const indexOfCurrentColumn = columnsForLevel.indexOf(this.column);
+                    adjacentColumn = columnsForLevel[indexOfCurrentColumn + 1];
+                }
+                this.service.adjacentColumn = adjacentColumn;
+            }
+            if (!this.service.adjacentColumn.parent) {
+                this.service.adjacentColumn.resizeStartWidth = adjacentColumnWidth(this.element);
+            }
+            if (this.service.adjacentColumn.isColumnGroup) {
+                this.foundColumn = null;
+                this.service.adjacentColumn = this.firstGroupChild(this.service.adjacentColumn);
+                const rowIndex = this.service.adjacentColumn.level + 1;
+                const colIndex = this.service.adjacentColumn.leafIndex + 1;
+                this.service.adjacentColumn.resizeStartWidth = adjacentColumnInGroupWidth(this.element, rowIndex, colIndex);
+            }
+        }
+        this.service.resizedColumn({
+            column: this.service.adjacentColumn,
+            oldWidth: this.service.adjacentColumn.resizeStartWidth
+        });
+    }
+    firstGroupChild(column) {
+        Array.from(column.children).sort((a, b) => a.orderIndex - b.orderIndex).forEach((c, idx) => {
+            if (idx === 0 && !c.isColumnGroup) {
+                if (!this.foundColumn) {
+                    this.foundColumn = c;
+                }
+            }
+            else if (c.isColumnGroup) {
+                this.firstGroupChild(c);
+            }
+        });
+        return this.foundColumn;
+    }
+    setGroupWidths(column) {
+        const childrenWidths = column.children.reduce((acc, c) => acc + c.width, 0);
+        column.width = childrenWidths;
+        column.children.forEach(c => {
+            if (c.isColumnGroup) {
+                this.setGroupWidths(c);
+            }
+        });
+    }
+    updateWidthOfDraggedColumn(column, width) {
+        this.totalChildrenSum = 0;
+        this.childrenColumns = [];
+        this.calcChildrenWidth(this.service.draggedGroupColumn);
+        const childrenWidthNotIncludingColumn = this.childrenColumns.reduce((acc, col) => {
+            return col !== column ? acc + col.width : acc;
+        }, 0);
+        this.service.draggedGroupColumn.width = childrenWidthNotIncludingColumn + width;
+        if (this.service.adjacentColumn.minResizableWidth <= this.totalChildrenSum + this.service.adjacentColumn.resizeStartWidth - width - childrenWidthNotIncludingColumn) {
+            this.service.adjacentColumn.width = this.totalChildrenSum + this.service.adjacentColumn.resizeStartWidth - width - childrenWidthNotIncludingColumn;
+        }
+    }
+    calcChildrenWidth(column) {
+        const columnChildren = Array.from(column.children);
+        const childrenNoGroups = columnChildren.filter(c => !c.isColumnGroup);
+        const childrenGroups = columnChildren.filter(c => c.isColumnGroup);
+        childrenNoGroups.forEach(col => {
+            if (this.childrenColumns.indexOf(col) === -1) {
+                this.childrenColumns.push(col);
+            }
+        });
+        this.totalChildrenSum += childrenNoGroups.reduce((acc, col) => acc + col.resizeStartWidth, 0);
+        childrenGroups.forEach((col) => {
+            this.calcChildrenWidth(col);
+        });
+    }
     columnsForLevel(level) {
         return columnsToRender(this.columns ? this.columns.filter(column => column.level === level) : []);
     }
+    minAdjacentColumnWidth(column) {
+        if (column.isColumnGroup) {
+            Array.from(column.children).forEach(c => {
+                this.minAdjacentColumnWidth(c);
+            });
+        }
+        else {
+            this.minWidthTotal += column.minResizableWidth;
+            if (column.width < column.minResizableWidth) {
+                column.width = column.minResizableWidth;
+            }
+        }
+        return this.minWidthTotal;
+    }
     getTableDelta(newWidth, delta) {
         const minWidth = this.column.minResizableWidth;
         const maxWidth = this.column.maxResizableWidth;
@@ -280,6 +449,18 @@ export class ColumnHandleDirective {
         event.stopPropagation();
         event.preventDefault();
     };
+    isLastInGroup(column) {
+        if (column.parent) {
+            const groupChildren = Array.from(column.parent.children);
+            const indexOfCurrentColumn = groupChildren.indexOf(column);
+            if (column.isReordered || column.orderIndex > 0 || (column.isReordered && column.orderIndex === 0)) {
+                return (column.orderIndex - groupChildren[0].orderIndex) === groupChildren.length - 1;
+            }
+            else {
+                return indexOfCurrentColumn === groupChildren.length - 1;
+            }
+        }
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ColumnHandleDirective, deps: [{ token: i1.DraggableDirective, host: true }, { token: i0.ElementRef }, { token: i2.ColumnResizingService }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }, { token: i3.ContextService }, { token: i4.ColumnInfoService }], target: i0.ɵɵFactoryTarget.Directive });
     static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: ColumnHandleDirective, isStandalone: true, selector: "[kendoGridColumnHandle]", inputs: { isLast: "isLast", columns: "columns", column: "column" }, host: { listeners: { "dblclick": "autoFit()" }, properties: { "style.display": "this.visible", "style.left": "this.leftStyle", "style.right": "this.rightStyle" } }, ngImport: i0 });
 }

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

@@ -27,8 +27,10 @@ export class ColumnResizingService {
     areColumnsReordered = false;
     isShiftPressed = false;
     originalWidth;
-    column;
+    draggedGroupColumn;
     resizedColumns;
+    autoFitResize = false;
+    column;
     tables = [];
     batch = null;
     start(column) {
@@ -64,7 +66,10 @@ export class ColumnResizingService {
             resizedColumns: this.resizedColumns,
             type: 'end'
         });
+        this.restoreInitialMaxMinWidths();
         this.adjacentColumn = null;
+        this.draggedGroupColumn = null;
+        this.autoFitResize = false;
     }
     registerTable(tableMetadata) {
         this.tables.push(tableMetadata);
@@ -137,6 +142,16 @@ export class ColumnResizingService {
         });
         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: "16.2.12", ngImport: i0, type: ColumnResizingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ColumnResizingService });
 }

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

@@ -91,7 +91,7 @@ export class TableDirective {
         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) {
+        if (isConstrainedMode && !this.service.autoFitResize) {
             this.renderer.setStyle(this.element.nativeElement, 'width', this.service.originalWidth + 'px');
         }
         else {

package/esm2022/columns/column-base.mjs

@@ -28,6 +28,18 @@ const isColumnContainer = column => column.isColumnGroup || isSpanColumn(column)
  */
 export class ColumnBase {
     parent;
+    /**
+     * @hidden
+     */
+    isReordered;
+    /**
+     * @hidden
+     */
+    initialMaxResizableWidth;
+    /**
+     * @hidden
+     */
+    initialMinResizableWidth;
     /**
      * @hidden
      */

package/esm2022/columns/column.component.mjs

@@ -116,6 +116,10 @@ export class ColumnComponent extends ColumnBase {
     get displayTitle() {
         return this.title === undefined ? this.field : this.title;
     }
+    ngAfterViewInit() {
+        this.initialMaxResizableWidth = this.maxResizableWidth;
+        this.initialMinResizableWidth = this.minResizableWidth;
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ColumnComponent, deps: [{ token: i1.ColumnBase, host: true, optional: true, skipSelf: true }, { token: i2.IdService, optional: true }], target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: ColumnComponent, isStandalone: true, selector: "kendo-grid-column", inputs: { field: "field", format: "format", sortable: "sortable", groupable: "groupable", editor: "editor", filter: "filter", filterable: "filterable", editable: "editable" }, providers: [
             {

package/esm2022/common/resizable-settings.mjs

@@ -0,0 +1,8 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2025 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * The size restrictions that will be applied to the resizable Grid.
+ */
+export {};