@progress/kendo-angular-grid 19.3.0-develop.22 → 19.3.0-develop.24

package/esm2022/navigation/navigation.service.mjs

@@ -11,7 +11,7 @@ import { GridFocusableElement } from './grid-focusable-element';
 import { NavigationCursor } from './navigation-cursor';
 import { NavigationModel } from './navigation-model';
 import { DomEventsService } from '../common/dom-events.service';
-import { isDocumentAvailable, isPresent, Keys } from '@progress/kendo-angular-common';
+import { hasClasses, isDocumentAvailable, isPresent, Keys } from '@progress/kendo-angular-common';
 import { EditService } from '../editing/edit.service';
 import { GroupsService } from '../grouping/groups.service';
 import { PagerContextService } from '@progress/kendo-angular-pager';
@@ -212,7 +212,12 @@ export class NavigationService {
         // Closing the editor will not always trigger focusout in Firefox.
         // To get around this, we ensure that the cell is closed after editing.
         this.editService.changes.pipe(filter(e => e.action !== 'edit' && this.mode === 2 /* NavigationMode.Content */), filter((e) => e.action === 'cellClose' && !e.prevented), switchMap(onStable))
-            .subscribe(() => this.leaveCell()));
+            .subscribe((e) => {
+            const isInStackedCell = closest(e.originalEvent?.target, (el) => hasClasses(el, 'k-grid-stack-content'));
+            if (!isInStackedCell) {
+                this.leaveCell();
+            }
+        }));
         this.subs.add(this.pagerContextService.pageChange
             .subscribe(() => this.cursor.reset(0, 0)));
         this.subs.add(this.domEvents.keydown
@@ -394,7 +399,7 @@ export class NavigationService {
             success = fwd ? this.cursor.moveDown(1) : this.cursor.moveUp(1);
             if (success) {
                 const row = this.cursor.row;
-                const colIdx = fwd ? 0 : this.cursor.lastCellIndex(row);
+                const colIdx = fwd || this.isStackedMode ? 0 : this.cursor.lastCellIndex(row);
                 this.cursor.reset(row.index, colIdx);
             }
         }
@@ -412,6 +417,12 @@ export class NavigationService {
         if (!cell) {
             return;
         }
+        if (this.tableCellEntered && this.isStackedMode) {
+            this.stackedCellEntered = true;
+        }
+        else {
+            this.tableCellEntered = true;
+        }
         const group = cell.focusGroup;
         const focusable = group && group.canFocus();
         this.mode = focusable ? 2 /* NavigationMode.Content */ : 1 /* NavigationMode.Cursor */;
@@ -419,6 +430,9 @@ export class NavigationService {
         if (focusable) {
             this.activateRow();
             group.focus();
+            if (this.isStackedMode && this.stackedFocusedCellIndex === -1) {
+                this.stackedFocusedCellIndex = 0;
+            }
         }
     }
     leaveCell() {
@@ -426,11 +440,22 @@ export class NavigationService {
         if (!cell) {
             return;
         }
+        if (this.tableCellEntered) {
+            if (this.stackedCellEntered) {
+                this.stackedCellEntered = false;
+            }
+            else {
+                this.tableCellEntered = false;
+            }
+        }
         const group = cell.focusGroup;
         const focusable = group && group.canFocus();
         if (!focusable) {
             this.deactivateElements();
         }
+        if (this.isStackedMode && this.stackedFocusedCellIndex > -1) {
+            this.stackedFocusedCellIndex = -1;
+        }
         this.mode = 1 /* NavigationMode.Cursor */;
         this.cursor.announce();
     }
@@ -445,11 +470,11 @@ export class NavigationService {
             .forEach(cell => cell.focusGroup && cell.focusGroup.activate());
     }
     moveCursorFwd() {
-        this.lastCellRowIndex = this.activeCell.rowIndex;
+        this.lastCellRowIndex = this.activeCell?.rowIndex;
         return this.ctx.localization.rtl ? this.cursor.moveLeft() : this.cursor.moveRight();
     }
     moveCursorBwd() {
-        this.lastCellRowIndex = this.activeCell.rowIndex;
+        this.lastCellRowIndex = this.activeCell?.rowIndex;
         return this.ctx.localization.rtl ? this.cursor.moveRight() : this.cursor.moveLeft();
     }
     onCursorKeydown(args) {
@@ -589,6 +614,15 @@ export class NavigationService {
                 break;
             case Keys.Enter:
             case Keys.F2: {
+                if (this.stackedCellEntered) {
+                    if (args.keyCode === Keys.F2 && row.dataRowIndex > -1) {
+                        this.zone.run(() => {
+                            this.editService.beginEdit(row.dataRowIndex);
+                        });
+                        this.enterCell();
+                    }
+                    break;
+                }
                 const groupItem = row.groupItem;
                 if (groupItem) {
                     this.zone.run(() => this.groupsService.toggleRow(groupItem));
@@ -597,6 +631,11 @@ export class NavigationService {
                     this.zone.run(() => this.detailsService.toggleRow(row.dataRowIndex, row.dataItem));
                 }
                 else {
+                    if (args.keyCode === Keys.F2 && row.dataRowIndex > -1) {
+                        this.zone.run(() => {
+                            this.editService.beginEdit(row.dataRowIndex);
+                        });
+                    }
                     this.enterCell();
                     if (!this.cursor.cell.focusGroup.isNavigable()) {
                         preventDefault = true;
@@ -604,6 +643,17 @@ export class NavigationService {
                 }
                 break;
             }
+            case Keys.Backspace:
+            case Keys.Delete:
+                if (this.activeRow && this.activeRow.dataRowIndex >= 0 && this.activeRow.dataItem) {
+                    if (!row.groupItem && !this.cursor.cell.detailExpandCell) {
+                        this.zone.run(() => {
+                            this.editService.remove(this.activeRow.dataRowIndex);
+                        });
+                        preventDefault = true;
+                    }
+                }
+                break;
             default:
                 if (!args.ctrlKey && !args.altKey && isPrintableCharacter(args.key)) {
                     this.enterCell();
@@ -627,6 +677,13 @@ export class NavigationService {
         }
         const confirm = !args.defaultPrevented && args.keyCode === Keys.Enter && isTextInput(args.target);
         if (args.keyCode === Keys.Escape || args.keyCode === Keys.F2 || confirm) {
+            if (this.tableCellEntered && args.keyCode === Keys.F2 && this.activeRow.dataRowIndex > -1) {
+                this.zone.run(() => {
+                    this.editService.beginEdit(this.activeRow.dataRowIndex);
+                });
+                this.enterCell();
+                return;
+            }
             this.leaveCell();
             this.cursor.reset();
             args.stopPropagation();
@@ -695,6 +752,12 @@ export class NavigationService {
         this.cursor.announce();
     }
     onKeydown(args) {
+        if (this.isStackedMode) {
+            this.handleStackedKeydown(args);
+            if (args.defaultPrevented) {
+                return;
+            }
+        }
         if (this.mode === 1 /* NavigationMode.Cursor */) {
             this.onCursorKeydown(args);
         }
@@ -783,6 +846,74 @@ export class NavigationService {
         const offset = direction === 'Up' ? Math.abs(this.lastCellRowIndex - this.activeRowIndex) : (this.activeRowIndex + cellRowspan - this.lastCellRowIndex - 1);
         return offset;
     }
+    get isStackedMode() {
+        return this.ctx?.grid?.isStacked;
+    }
+    handleStackedKeydown(args) {
+        const target = args.target;
+        const stackedCell = closest(target, (el) => hasClasses(el, 'k-grid-stack-cell'));
+        const tableCell = closest(target, (el) => hasClasses(el, 'k-table-td'));
+        const isInStackedCell = closest(target, (el) => hasClasses(el, 'k-grid-stack-content'));
+        if (!stackedCell || !tableCell) {
+            return;
+        }
+        if (args.keyCode === Keys.Tab) {
+            this.handleStackedTabNavigation(args);
+        }
+        else if (args.keyCode === Keys.Backspace || args.keyCode === Keys.Delete) {
+            if (this.activeRow && this.activeRow.dataRowIndex >= 0 && this.activeRow.dataItem) {
+                const row = this.cursor.row;
+                if (!row.groupItem && !this.cursor.cell.detailExpandCell) {
+                    this.zone.run(() => {
+                        this.editService.remove(this.activeRow.dataRowIndex);
+                    });
+                    args.preventDefault();
+                }
+            }
+        }
+        else if (isInStackedCell && (args.keyCode === Keys.Enter || args.keyCode === Keys.Escape)) {
+            this.editService.closeCell(args);
+            this.activeCell.focusGroup.activate();
+            this.activeCell.focusGroup.focusableChildren[this.stackedFocusedCellIndex]?.focus();
+            args.preventDefault();
+        }
+    }
+    stackedFocusedCellIndex = -1;
+    tableCellEntered = false;
+    stackedCellEntered = false;
+    handleStackedTabNavigation(args) {
+        if (!isPresent(this.activeCell.focusGroup)) {
+            return;
+        }
+        if (this.stackedFocusedCellIndex === -1) {
+            return;
+        }
+        const stackedCells = this.activeCell.focusGroup.focusableChildren;
+        let nextIndex;
+        if (args.shiftKey) {
+            nextIndex = this.stackedFocusedCellIndex - 1;
+            if (nextIndex < 0) {
+                nextIndex = stackedCells.length - 1;
+            }
+        }
+        else {
+            nextIndex = this.stackedFocusedCellIndex + 1;
+            if (nextIndex >= stackedCells.length) {
+                nextIndex = 0;
+            }
+        }
+        let nextStackedCell = stackedCells[nextIndex];
+        if (nextStackedCell) {
+            if (nextStackedCell.hasFocus() || (isDocumentAvailable() && document.activeElement === nextStackedCell.hostElement.nativeElement)) {
+                // next cell is already focused (as a focusable child of the previous one), skip to the next one
+                nextIndex = args.shiftKey ? this.stackedFocusedCellIndex - 2 : this.stackedFocusedCellIndex + 2;
+                nextStackedCell = stackedCells[nextIndex];
+            }
+            nextStackedCell.focus();
+            this.stackedFocusedCellIndex = nextIndex;
+            args.preventDefault();
+        }
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NavigationService, deps: [{ token: i0.NgZone }, { token: i1.DomEventsService }, { token: i2.PagerContextService }, { token: i3.ScrollRequestService }, { token: i4.GroupsService }, { token: i5.DetailsService }, { token: i6.FocusRoot }, { token: i7.EditService }, { token: i0.ChangeDetectorRef }, { token: i8.ContextService }, { token: i9.ColumnResizingService }, { token: i10.FocusableDirective, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NavigationService });
 }

package/esm2022/package-metadata.mjs

@@ -10,7 +10,7 @@ export const packageMetadata = {
     productName: 'Kendo UI for Angular',
     productCode: 'KENDOUIANGULAR',
     productCodes: ['KENDOUIANGULAR'],
-    publishDate: 1754479136,
-    version: '19.3.0-develop.22',
+    publishDate: 1754485381,
+    version: '19.3.0-develop.24',
     licensingDocsUrl: 'https://www.telerik.com/kendo-angular-ui/my-license/'
 };

package/esm2022/pdf/export-element.mjs

@@ -80,11 +80,14 @@ const createTable = (colGroups, headers, bodies, footers, size) => {
     for (let idx = 1; idx < colGroups.length; idx++) {
         appendNodes(colGroup, colGroups[idx].querySelectorAll('col'));
     }
-    const header = createTableElement(headers);
     const body = createTableElement(bodies);
-    setFirstCellClass(header, headers);
+    let header;
+    if (headers.length > 0) {
+        header = createTableElement(headers);
+        setFirstCellClass(header, headers);
+    }
     table.appendChild(colGroup);
-    table.appendChild(header);
+    header && table.appendChild(header);
     table.appendChild(body);
     if (footers.length) {
         const footer = createTableElement(footers);
@@ -101,17 +104,23 @@ export const exportElement = (wrapper, size) => {
     let result;
     if (content) {
         const colGroups = [content.querySelector('colgroup')];
-        const headers = [query.header().querySelector('thead')];
         const bodies = [content.querySelector('tbody')];
+        const header = query.header();
         const footer = query.footer();
+        const headers = [];
         const footers = [];
+        if (header) {
+            headers.push(header.querySelector('thead'));
+        }
         if (footer) {
             footers.push(footer.querySelector('tfoot'));
         }
         const lockedContent = query.content(true);
         if (lockedContent) {
+            if (headers.length > 0) {
+                headers.unshift(query.header(true).querySelector('thead'));
+            }
             colGroups.unshift(lockedContent.querySelector('colgroup'));
-            headers.unshift(query.header(true).querySelector('thead'));
             bodies.unshift(lockedContent.querySelector('tbody'));
             if (footer) {
                 footers.unshift(query.footer(true).querySelector('tfoot'));

package/esm2022/pdf/pdf.component.mjs

@@ -164,7 +164,9 @@ export class PDFComponent extends PDFExportComponent {
             const overlayContent = overlayQuery.content();
             overlayContent.scrollTop = content.scrollTop;
             overlayContent.scrollLeft = content.scrollLeft;
-            overlayQuery.header().scrollLeft = query.header().scrollLeft;
+            if (!this.ctx?.grid?.isStacked) {
+                overlayQuery.header().scrollLeft = query.header().scrollLeft;
+            }
             const footer = query.footer();
             if (footer) {
                 overlayQuery.footer().scrollLeft = footer.scrollLeft;