@progress/kendo-angular-grid 21.4.1-develop.1 → 22.0.0-develop.1

package/esm2022/rendering/list.component.mjs

@@ -1,1176 +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, Input, Output, EventEmitter, HostBinding, ViewChild, ElementRef, Inject, InjectionToken, QueryList, NgZone, Renderer2, ViewChildren, ChangeDetectorRef, TemplateRef } from '@angular/core';
-import { Subject, fromEvent, merge } from 'rxjs';
-import { delay, map, filter, tap, take, switchMapTo } from 'rxjs/operators';
-import { RowHeightService } from '../scrolling/row-height.service';
-import { ScrollerService, PageAction, ScrollAction, ScrollBottomAction } from '../scrolling/scroller.service';
-import { ScrollRequestService } from '../scrolling/scroll-request.service';
-import { ColumnBase } from '../columns/column-base';
-import { DetailTemplateDirective } from './details/detail-template.directive';
-import { isChanged, isPresent, isUniversal, anyChanged, isNumber, requestAnimationFrame, cancelAnimationFrame, recursiveFlatMap, calcRowHeight } from '../utils';
-import { DetailsService } from './details/details.service';
-import { ColumnsContainer } from '../columns/columns-container';
-import { ChangeNotificationService } from '../data/change-notification.service';
-import { syncRowsHeight } from '../layout/row-sync';
-import { NoRecordsTemplateDirective } from './no-records-template.directive';
-import { SuspendService } from '../scrolling/suspend.service';
-import { GroupsService } from "../grouping/groups.service";
-import { expandColumns, sumColumnWidths } from "../columns/column-common";
-import { ScrollSyncService } from "../scrolling/scroll-sync.service";
-import { ResizeService } from "../layout/resize.service";
-import { EventsOutsideAngularDirective, isDocumentAvailable, normalizeKeys, ResizeSensorComponent } from "@progress/kendo-angular-common";
-import { BrowserSupportService } from "../layout/browser-support.service";
-import { EditService } from '../editing/edit.service';
-import { NavigationService } from '../navigation/navigation.service';
-import { Keys } from '@progress/kendo-angular-common';
-import { ColumnResizingService } from "../column-resizing/column-resizing.service";
-import { GROUP_CELL_WIDTH } from '../constants';
-import { defaultTrackBy } from '../common/default-track-by';
-import { hasClasses, rtlScrollPosition } from './common/dom-queries';
-import { PDFService } from '../pdf/pdf.service';
-import { ColumnInfoService } from '../common/column-info.service';
-import { NON_DATA_CELL_CLASSES } from './constants';
-import { ContextService } from '../common/provider.service';
-import { ResizableContainerDirective } from '../layout/resizable.directive';
-import { TableBodyComponent } from './table-body.component';
-import { ColGroupComponent } from './common/col-group.component';
-import { GridTableDirective } from './grid-table.directive';
-import { TableDirective } from '../column-resizing/table.directive';
-import { DataMappingService } from '../data/data-mapping.service';
-import * as i0 from "@angular/core";
-import * as i1 from "./details/details.service";
-import * as i2 from "../data/change-notification.service";
-import * as i3 from "../scrolling/suspend.service";
-import * as i4 from "../grouping/groups.service";
-import * as i5 from "../scrolling/scroll-sync.service";
-import * as i6 from "../layout/resize.service";
-import * as i7 from "../editing/edit.service";
-import * as i8 from "../layout/browser-support.service";
-import * as i9 from "../navigation/navigation.service";
-import * as i10 from "../scrolling/scroll-request.service";
-import * as i11 from "../common/provider.service";
-import * as i12 from "../column-resizing/column-resizing.service";
-import * as i13 from "../pdf/pdf.service";
-import * as i14 from "../common/column-info.service";
-import * as i15 from "../data/data-mapping.service";
-const elementAt = (index, elements, elementOffset) => {
-    for (let idx = 0, elementIdx = 0; idx < elements.length; idx++) {
-        const offset = elementOffset(elements[idx]);
-        if (elementIdx <= index && index <= elementIdx + offset - 1) {
-            return elements[idx];
-        }
-        elementIdx += offset;
-    }
-};
-const rowAt = (index, rows) => elementAt(index, rows, () => 1);
-const cellAt = (index, cells) => elementAt(index, cells, cell => !hasClasses(cell, NON_DATA_CELL_CLASSES) ? parseInt(cell.getAttribute('colSpan'), 10) || 1 : 0);
-const EMPTY_OBJECT = {};
-/**
- * @hidden
- */
-export const SCROLLER_FACTORY_TOKEN = new InjectionToken('grid-scroll-service-factory');
-/**
- * @hidden
- */
-export function DEFAULT_SCROLLER_FACTORY(observable, ctx) {
-    return new ScrollerService(observable, ctx);
-}
-const wheelDeltaY = (e) => {
-    const deltaY = e.wheelDeltaY;
-    if (e.wheelDelta && (deltaY === undefined || deltaY)) {
-        return e.wheelDelta;
-    }
-    else if (e.detail && e.axis === e.VERTICAL_AXIS) {
-        return (-e.detail) * 10;
-    }
-    return 0;
-};
-const preventLockedScroll = (args, element) => {
-    const delta = wheelDeltaY(args);
-    const scrollTop = element.scrollTop;
-    const allowScroll = (scrollTop === 0 && 0 < delta) || (element.scrollHeight <= element.offsetHeight + scrollTop && delta < 0);
-    if (!allowScroll) {
-        args.preventDefault();
-    }
-};
-const translateY = (renderer, value) => el => renderer.setStyle(el, "transform", `translateY(${value}px)`);
-const maybeNativeElement = el => el ? el.nativeElement : null;
-const hasScrollbar = (el, parent) => el.nativeElement.offsetWidth > parent.nativeElement.clientWidth;
-const setHeight = renderer => ({ el, height }) => renderer.setStyle(el, "height", `${height}px`);
-const bufferSize = 1;
-/**
- * @hidden
- */
-export class ListComponent {
-    changeNotification;
-    suspendService;
-    groupsService;
-    ngZone;
-    renderer;
-    scrollSyncService;
-    resizeService;
-    editService;
-    supportService;
-    navigationService;
-    ctx;
-    columnResizingService;
-    changeDetector;
-    pdfService;
-    columnInfo;
-    dataMappingService;
-    hostClass = true;
-    hostRole = 'presentation';
-    data;
-    groups = [];
-    total;
-    rowHeight;
-    detailRowHeight;
-    take;
-    skip = 0;
-    columns = new ColumnsContainer(() => []);
-    detailTemplate;
-    noRecordsTemplate;
-    selectable = false;
-    groupable = false;
-    filterable;
-    rowClass;
-    rowSticky;
-    loading;
-    trackBy = defaultTrackBy;
-    virtualColumns;
-    isVirtual;
-    cellLoadingTemplate;
-    loadingTemplate;
-    sort = new Array();
-    size = 'medium';
-    contentScroll = new EventEmitter();
-    pageChange = new EventEmitter();
-    scrollBottom = new EventEmitter();
-    columnsStartIdx = 0;
-    allItems = [];
-    itemsToRender = [];
-    get showFooter() {
-        return this.groupable && this.groupable.showFooter;
-    }
-    get totalWidth() {
-        if (this.virtualColumns && this.columns.unlockedWidth) {
-            return this.columns.unlockedWidth;
-        }
-    }
-    container;
-    lockedContainer;
-    lockedTable;
-    table;
-    resizeSensors = new QueryList();
-    scroller;
-    subscriptions;
-    scrollerSubscription;
-    dispatcher = new Subject();
-    rowHeightService;
-    skipScroll;
-    rebind;
-    containerScrollTop = 0;
-    viewportColumns;
-    columnsEndIdx;
-    viewportColumnsWidth;
-    scrollLeft = 0;
-    virtualPageSize;
-    observer;
-    get lockedLeafColumns() {
-        return this.columns.lockedLeafColumns;
-    }
-    get nonLockedLeafColumns() {
-        return this.columns.nonLockedLeafColumns;
-    }
-    get nonLockedColumnsToRender() {
-        if (this.virtualColumns && !this.pdfService.exporting && !this.isStacked) {
-            return this.viewportColumns;
-        }
-        return this.nonLockedLeafColumns;
-    }
-    get leafColumns() {
-        return this.columns.leafColumnsToRender;
-    }
-    get lockedWidth() {
-        const groupCellsWidth = this.groups.length * GROUP_CELL_WIDTH;
-        return expandColumns(this.lockedLeafColumns.toArray()).reduce((prev, curr) => prev + (curr.width || 0), groupCellsWidth);
-    }
-    get nonLockedWidth() {
-        if (((!this.rtl && this.lockedLeafColumns.length) || this.virtualColumns) && !this.isStacked) {
-            return sumColumnWidths(expandColumns(this.nonLockedColumnsToRender.toArray()));
-        }
-        return undefined;
-    }
-    get isLocked() {
-        return this.lockedLeafColumns.length > 0 && !this.isStacked;
-    }
-    rtl = false;
-    columnUpdateFrame;
-    hasLockedContainer;
-    minRowHeight;
-    handleSkipOnData = false;
-    scrollToIndex = null;
-    constructor(scrollerFactory, detailsService, changeNotification, suspendService, groupsService, ngZone, renderer, scrollSyncService, resizeService, editService, supportService, navigationService, scrollRequestService, ctx, columnResizingService, changeDetector, pdfService, columnInfo, dataMappingService) {
-        this.changeNotification = changeNotification;
-        this.suspendService = suspendService;
-        this.groupsService = groupsService;
-        this.ngZone = ngZone;
-        this.renderer = renderer;
-        this.scrollSyncService = scrollSyncService;
-        this.resizeService = resizeService;
-        this.editService = editService;
-        this.supportService = supportService;
-        this.navigationService = navigationService;
-        this.ctx = ctx;
-        this.columnResizingService = columnResizingService;
-        this.changeDetector = changeDetector;
-        this.pdfService = pdfService;
-        this.columnInfo = columnInfo;
-        this.dataMappingService = dataMappingService;
-        this.scroller = this.ctx.scroller = scrollerFactory(this.dispatcher, this.ctx);
-        this.subscriptions = detailsService.changes.subscribe(() => this.detailExpand());
-        this.subscriptions.add(scrollRequestService.requests.subscribe(req => isPresent(req.adjustIndex) ? this.scrollTo(req.request, req.adjustIndex) : this.scrollToItem(req.request)));
-        this.subscriptions.add(this.pdfService.restoreDOMVirtualization.subscribe(() => {
-            this.ngZone.onStable.pipe(take(1)).subscribe(() => {
-                this.init();
-                this.setScrollerOptions();
-                this.scroller.update();
-            });
-        }));
-    }
-    ngOnInit() {
-        this.minRowHeight = this.isVirtual ? this.rowHeight || calcRowHeight(this.table.nativeElement) : this.rowHeight;
-        this.init();
-        this.subscriptions.add(this.ngZone.runOutsideAngular(this.handleRowSync.bind(this)));
-        this.subscriptions.add(this.groupsService.changes.subscribe(() => {
-            this.skipScroll = this.isVirtual;
-        }));
-        this.subscriptions.add(this.ngZone.runOutsideAngular(this.handleRowNavigationLocked.bind(this)));
-        this.subscriptions.add(merge(this.columns.changes, this.resizeService.changes).subscribe(() => {
-            if (this.virtualColumns) {
-                this.ngZone.run(() => {
-                    this.updateViewportColumns();
-                    this.changeDetector.markForCheck();
-                });
-            }
-        }));
-        this.subscriptions.add(this.ctx.localization.changes.subscribe(({ rtl }) => this.rtl = rtl));
-    }
-    ngOnChanges(changes) {
-        if (!isDocumentAvailable()) {
-            return;
-        }
-        const changesInSkip = changes['skip'];
-        const hasInitialSkip = changesInSkip && changesInSkip.firstChange && changesInSkip.currentValue > 0;
-        if (hasInitialSkip) {
-            this.handleSkipOnData = true;
-        }
-        if (isChanged('isVirtual', changes)) {
-            if (this.isVirtual && !(this.minRowHeight || this.rowHeight)) {
-                this.minRowHeight = calcRowHeight(this.table.nativeElement);
-            }
-            this.ngZone.onStable.pipe(take(1)).subscribe(() => {
-                this.scroller.reset();
-                this.rowHeightService = this.scroller.rowHeightService = new RowHeightService(this.total, this.rowHeight || this.minRowHeight);
-                this.setScrollerOptions();
-                this.scroller.update();
-            });
-        }
-        if (isChanged("skip", changes) && !this.rebind) {
-            this.skipScroll = true;
-            this.container.nativeElement.scrollTop = (this.isVirtual && this.ctx.grid?.pageable) ? 0 : this.rowHeightService.offset(this.skip);
-        }
-        if (anyChanged(['total', 'take'], changes)) {
-            // For virtual scrolling without paging, preserve scroll position when only take/pageSize changes
-            const isVirtualOnly = this.isVirtual && !this.ctx.grid?.pageable;
-            const onlyTakeChanged = isChanged('take', changes) && !isChanged('total', changes);
-            if (isVirtualOnly && onlyTakeChanged) {
-                this.skipScroll = true;
-            }
-            this.init();
-        }
-        this.rebind = false;
-    }
-    zoneSub;
-    get totalIsAllItems() {
-        return this.isVirtual && (Boolean(this.ctx.grid?.pageable || this.ctx.grid?.group?.length));
-    }
-    rebindGroupedDataFlag = false;
-    ngDoCheck() {
-        if (this.virtualColumns && (!this.viewportColumns || this.viewportWidthChange())) {
-            this.updateViewportColumns();
-        }
-        if (!isPresent(this.virtualPageSize) && !this.ctx.grid?.pageable && isPresent(this.ctx.grid?.pageSize)) {
-            this.virtualPageSize = this.ctx.grid.pageSize;
-        }
-        const shouldCalculatePageSize = isDocumentAvailable() && this.isVirtual && !isPresent(this.virtualPageSize) && (!isPresent(this.ctx.grid?.pageSize) || this.ctx.grid?.pageable);
-        const previousTotal = this.allItems.length;
-        this.allItems = this.dataMappingService.dataMapper(this.data, this.nonLockedColumnsToRender, this.lockedLeafColumns, this.detailTemplate, this.showFooter);
-        const totalChanged = previousTotal !== this.allItems.length;
-        const totalIncreased = this.allItems.length > previousTotal;
-        if (this.totalIsAllItems && totalChanged) {
-            this.scroller.reset(this.skipScroll);
-            this.scroller.total = this.allItems.length;
-            this.itemsToRender = this.allItems.slice(this.scroller.virtualSkip, this.scroller.virtualSkip + this.virtualPageSize);
-        }
-        else if (totalChanged && !this.ctx.grid?.group?.length) {
-            // Preserve scroll position for non-virtual endless scrolling (scrollBottom event)
-            if (!this.isVirtual && totalIncreased) {
-                this.scroller.total = this.total;
-            }
-            else {
-                this.scroller.reset(this.skipScroll);
-                this.scroller.total = this.total;
-                // Clear flags to allow viewport update on next change detection (virtual scrolling fix)
-                this.skipScroll = false;
-                this.scroller.scrollSyncing = false;
-            }
-        }
-        if (!this.isVirtual || (this.isVirtual && !this.ctx.grid?.pageable && !this.ctx.grid?.group?.length)) {
-            this.itemsToRender = this.allItems;
-        }
-        const rebindGroupedData = this.isVirtual && !totalChanged && this.ctx.grid?.group?.length && !this.rebindGroupedDataFlag;
-        if (rebindGroupedData) {
-            this.rebindGroupedDataFlag = true;
-        }
-        if (shouldCalculatePageSize || !isPresent(this.scroller.rowHeightService)) {
-            const calculatedPageSize = this.virtualPageSize ?? this.calcVirtualPageSize();
-            if (calculatedPageSize > 0) {
-                this.ngZone.onStable.pipe(take(1)).subscribe(() => {
-                    if (!isPresent(this.ctx.grid?.pageSize)) {
-                        this.ctx.grid.pageSize = calculatedPageSize;
-                        this.ngZone.run(() => {
-                            this.pageChange.emit({
-                                skip: this.skip || 0,
-                                take: calculatedPageSize
-                            });
-                        });
-                    }
-                    if (this.ctx.grid?.pageable || this.ctx.grid?.group?.length) {
-                        this.virtualPageSize = this.scroller.virtualPageSize = calculatedPageSize;
-                        this.ngZone.run(() => this.itemsToRender = this.allItems.slice(this.scroller.virtualSkip, this.scroller.virtualSkip + this.virtualPageSize));
-                    }
-                });
-            }
-        }
-        else if (this.rebindGroupedDataFlag) {
-            this.ngZone.run(() => this.itemsToRender = this.allItems.slice(this.scroller.virtualSkip, this.scroller.virtualSkip + this.virtualPageSize));
-            this.rebindGroupedDataFlag = false;
-        }
-        if (!this.zoneSub) {
-            this.zoneSub = this.ngZone.onStable.subscribe(() => {
-                if (!this.scroller.rowHeightService) {
-                    const total = this.isVirtual && (this.ctx.grid?.pageable || this.ctx.grid?.group?.length) ? this.allItems.length : this.total;
-                    this.scroller.rowHeightService = this.rowHeightService = new RowHeightService(total, this.rowHeight || this.minRowHeight);
-                }
-                if (this.allItems.length && this.handleSkipOnData && this.isVirtual && this.skip > 0 && this.total > 0) {
-                    this.ngZone.onStable.pipe(take(1)).subscribe(() => {
-                        this.scroller.adjustScroll(this.scroller.rowHeightService.offset(this.skip), true);
-                        this.handleSkipOnData = false;
-                    });
-                }
-                if (this.isVirtual && this.ctx.grid?.group?.length && this.scroller.total !== this.allItems.length) {
-                    this.scroller.total = this.allItems.length;
-                    this.rowHeightService = this.scroller.rowHeightService = new RowHeightService(this.scroller.total, this.rowHeight || this.minRowHeight);
-                }
-                this.isVirtual && this.scroller.update();
-                // Item outside of the viewport is scrolled to programmatically.
-                // RowHeightService offset for given index still may not match the current scrollTop
-                // depending on the varying row heights, so we need to adjust the scroll position.
-                if (isPresent(this.scrollToIndex)) {
-                    const offset = this.scroller.rowHeightService.offset(this.scrollToIndex);
-                    if (offset > this.container.nativeElement.scrollTop) {
-                        this.scroller.adjustScroll(offset - this.container.nativeElement.scrollTop);
-                    }
-                    this.scrollToIndex = null;
-                }
-                if (this.isVirtual) {
-                    this.ctx.grid?.updateNavigationMetadata();
-                    // when navigating down from the header to content, skip navigation to the content
-                    // that would be triggered by the resetNavigationViewport method to ensure that the
-                    // focus is correctly set on the first data row in the content area.
-                    const shouldResetViewport = !this.navigationService.activeRow || this.navigationService.activeRow?.dataRowIndex > -1 || isPresent(this.navigationService.activeRow?.groupItem);
-                    if (shouldResetViewport) {
-                        this.resetNavigationViewport();
-                    }
-                }
-                this.zoneSub.unsubscribe();
-                this.zoneSub = null;
-            });
-        }
-    }
-    ngAfterViewInit() {
-        if (!isDocumentAvailable()) {
-            return;
-        }
-        this.attachContainerScroll();
-        this.initResizeService();
-        this.setScrollerOptions();
-    }
-    ngAfterViewChecked() {
-        const isLocked = this.isLocked;
-        if (isLocked && !this.hasLockedContainer) {
-            this.syncRowsHeight();
-        }
-        this.hasLockedContainer = isLocked;
-    }
-    syncRowsHeight() {
-        if (this.lockedContainer) {
-            syncRowsHeight(this.lockedTable.nativeElement, this.table.nativeElement);
-        }
-    }
-    ngOnDestroy() {
-        if (this.subscriptions) {
-            this.subscriptions.unsubscribe();
-        }
-        if (this.zoneSub) {
-            this.zoneSub.unsubscribe();
-            this.zoneSub = null;
-        }
-        if (this.resizeService) {
-            this.resizeService.destroy();
-        }
-        this.observer?.disconnect();
-        this.cleanupScroller();
-    }
-    init() {
-        if (this.suspendService.scroll) {
-            return;
-        }
-        const total = this.isVirtual && this.ctx.grid?.pageable ? this.ctx.grid.pageSize : this.total;
-        this.rowHeightService = this.scroller.rowHeightService = new RowHeightService(total, this.rowHeight || this.minRowHeight);
-        if (!isUniversal()) {
-            if (this.skipScroll) {
-                // Update scroller's take value when preserving scroll position
-                this.scroller.take = this.take;
-                this.scroller.total = this.total;
-                this.setScrollerOptions();
-                this.scroller.update();
-            }
-            else {
-                this.ngZone.runOutsideAngular(this.createScroller.bind(this));
-            }
-        }
-    }
-    lockedScroll() {
-        if (!this.suspendService.scroll) {
-            const lockedScrollTop = this.lockedContainer.nativeElement.scrollTop;
-            if (lockedScrollTop !== this.containerScrollTop) {
-                this.container.nativeElement.scrollTop = this.containerScrollTop = lockedScrollTop;
-            }
-        }
-    }
-    lockedMousewheel(args) {
-        if (!args.ctrlKey) {
-            preventLockedScroll(args, this.container.nativeElement);
-            const scrollDelta = wheelDeltaY(args);
-            this.container.nativeElement.scrollTop -= scrollDelta;
-        }
-    }
-    lockedKeydown(args) {
-        // on some keyboards arrow keys, PageUp/Down, and Home/End are mapped to Numpad keys
-        const code = normalizeKeys(args);
-        if (code === Keys.PageDown || code === Keys.PageUp) {
-            const dir = code === Keys.PageDown ? 1 : -1;
-            const element = this.container.nativeElement;
-            element.scrollTop += element.offsetHeight * dir * 0.8;
-            args.preventDefault();
-        }
-    }
-    updateViewportColumns(range) {
-        const columns = this.columns.nonLockedLeafColumns.toArray();
-        // eslint-disable-next-line prefer-const
-        let { startIdx, endIdx, offset } = range || this.calculateViewportColumns();
-        const start = Math.max(0, startIdx - bufferSize);
-        const end = Math.min(endIdx + bufferSize, columns.length - 1);
-        if (start < startIdx) {
-            for (let idx = startIdx - 1; idx >= start; idx--) {
-                offset -= columns[idx].width;
-            }
-        }
-        let currentColumns = columns.slice(start, end + 1);
-        this.viewportColumnsWidth = currentColumns.reduce((total, column) => total + column.width, 0);
-        const stickyBeforeStart = columns.slice(0, start).filter(c => c.sticky && !currentColumns.some(col => col === c));
-        const stickyAfterEnd = columns.slice(end, columns.length).filter(c => c.sticky && !currentColumns.some(col => col === c));
-        currentColumns = [...stickyBeforeStart, ...currentColumns, ...stickyAfterEnd];
-        if (start > 0) {
-            const offsetColumn = new ColumnBase();
-            offsetColumn.width = offset;
-            currentColumns.unshift(offsetColumn);
-        }
-        this.viewportColumns = new QueryList();
-        this.viewportColumns.reset(currentColumns);
-        this.columnsStartIdx = start;
-        this.columnsEndIdx = end;
-        this.columnInfo.columnRangeChange.emit({ start, end, offset });
-        if (!range) {
-            this.updateColumnViewport(startIdx, endIdx);
-        }
-    }
-    /**
-     * @hidden
-     */
-    get isStacked() {
-        return this.ctx.grid?.isStacked;
-    }
-    resetNavigationViewport() {
-        if (!isDocumentAvailable()) {
-            return;
-        }
-        if (this.skipScroll || this.scroller.scrollSyncing) {
-            this.ngZone.runOutsideAngular(() => {
-                setTimeout(() => {
-                    this.skipScroll = this.scroller.scrollSyncing = false;
-                });
-            });
-            return;
-        }
-        if (!this.container || !this.navigationService.tableEnabled ||
-            !this.navigationService.needsViewport() || this.allItems.length === 0) {
-            return;
-        }
-        const { scrollTop, offsetHeight } = this.container.nativeElement;
-        const scrollBottom = scrollTop + offsetHeight;
-        const firstItemIndex = this.rowHeightService.index(scrollTop);
-        const lastItemIndex = this.rowHeightService.index(scrollBottom);
-        const lastItemOffset = this.rowHeightService.offset(lastItemIndex);
-        let viewportStart = firstItemIndex;
-        let viewportEnd = lastItemIndex;
-        if (isPresent(this.detailTemplate)) {
-            viewportStart *= 2;
-            viewportEnd *= 2;
-            const firstItemHeight = this.rowHeightService.offset(firstItemIndex);
-            if (firstItemHeight + this.rowHeight < scrollTop) {
-                viewportStart++;
-            }
-            const lastItemHeight = this.rowHeightService.height(lastItemIndex);
-            const lastItemExpanded = this.scroller.isExpanded(lastItemIndex);
-            const lastItemDetailOverflows = lastItemOffset + lastItemHeight > scrollBottom;
-            if (lastItemExpanded && !lastItemDetailOverflows) {
-                viewportEnd++;
-            }
-        }
-        const offset = this.isVirtual && this.ctx.grid?.pageable ? this.skip : 0;
-        this.navigationService.setViewport(viewportStart + offset, viewportEnd + offset);
-    }
-    detailExpand() {
-        this.resetNavigationViewport();
-    }
-    attachContainerScroll() {
-        if (isUniversal()) {
-            return;
-        }
-        this.ngZone.runOutsideAngular(() => {
-            this.subscriptions.add(fromEvent(this.container.nativeElement, 'scroll').pipe(map((event) => event.target), filter(() => !this.suspendService.scroll), tap((target) => {
-                this.onContainerScroll(target);
-                this.resetNavigationViewport();
-                if (this.virtualColumns || this.isVirtual) {
-                    this.handleColumnScroll();
-                }
-                const rowViewport = this.navigationService.viewport || EMPTY_OBJECT;
-                const columnViewport = this.navigationService.columnViewport || EMPTY_OBJECT;
-                this.contentScroll.emit({
-                    scrollLeft: target.scrollLeft,
-                    scrollTop: target.scrollTop,
-                    startRow: rowViewport.firstItemIndex,
-                    endRow: rowViewport.lastItemIndex,
-                    startColumn: columnViewport.firstItemIndex,
-                    endColumn: columnViewport.lastItemIndex
-                });
-            })).subscribe(this.dispatcher));
-        });
-        this.scrollSyncService.registerEmitter(this.container.nativeElement, 'body');
-    }
-    createScroller() {
-        this.cleanupScroller();
-        const observable = this.scroller
-            .create(this.rowHeightService, this.skip, this.take, this.total);
-        this.skipScroll = false;
-        this.scrollerSubscription = observable.pipe(filter((x) => x instanceof PageAction), filter((x) => {
-            const temp = this.skipScroll;
-            this.skipScroll = false;
-            return !temp && x.skip !== this.skip;
-        }), tap(() => this.rebind = true))
-            .subscribe((x) => this.ngZone.run(() => this.pageChange.emit(x)));
-        this.scrollerSubscription.add(observable.pipe(filter((x) => x instanceof ScrollAction))
-            .subscribe(this.scroll.bind(this)));
-        this.scrollerSubscription.add(observable.pipe(filter((x) => x instanceof ScrollBottomAction))
-            .subscribe(() => this.scrollBottom.emit()));
-    }
-    scroll(scrollActionArgs) {
-        this.skipScroll = false;
-        if (this.isVirtual) {
-            [
-                maybeNativeElement(this.table),
-                maybeNativeElement(this.lockedTable)
-            ].filter(isPresent).forEach(translateY(this.renderer, scrollActionArgs.offset));
-            if (this.virtualPageSize && scrollActionArgs.changeVirtualData && (this.ctx.grid.pageable || this.ctx.grid.group?.length)) {
-                this.ngZone.run(() => this.itemsToRender = this.allItems.slice(this.scroller.virtualSkip, this.scroller.virtualSkip + this.virtualPageSize));
-            }
-        }
-        this.resetNavigationViewport();
-    }
-    onContainerScroll({ scrollTop }) {
-        this.containerScrollTop = scrollTop;
-        if (this.lockedContainer) {
-            this.lockedContainer.nativeElement.scrollTop = scrollTop;
-        }
-    }
-    handleRowSync() {
-        const isLocked = () => isPresent(this.lockedContainer);
-        const onStable = () => this.ngZone.onStable.asObservable().pipe(take(1));
-        return merge(this.changeNotification.changes, this.groupsService.changes
-            .pipe(filter(isLocked), switchMapTo(onStable())), this.editService.changed, this.resizeService.changes, this.columnResizingService.changes
-            .pipe(filter(change => change.type === 'end')), this.supportService.changes)
-            .pipe(filter(isLocked))
-            .subscribe(() => {
-            const scrollTop = this.container.nativeElement.scrollTop;
-            const scrollLeft = this.container.nativeElement.scrollLeft;
-            this.syncRowsHeight();
-            this.syncContainerHeight();
-            this.lockedContainer.nativeElement.scrollTop = this.container.nativeElement.scrollTop = scrollTop;
-            // fixes scroll left position in IE when editing
-            this.container.nativeElement.scrollLeft = scrollLeft;
-            this.resizeSensors.forEach(sensor => sensor.acceptSize());
-        });
-    }
-    handleRowNavigationLocked() {
-        return this.navigationService.changes.pipe(filter(() => isPresent(this.lockedContainer)), delay(10)).subscribe((args) => {
-            if (this.lockedLeafColumns.length <= args.prevColIndex && args.colIndex < this.lockedLeafColumns.length) {
-                const cell = this.navigationService.activeCell;
-                if (cell && cell.colIndex + cell.colSpan < args.prevColIndex) {
-                    this.container.nativeElement.scrollLeft = 0;
-                }
-            }
-        });
-    }
-    scrollToVirtualRow(itemIndex, adjustIndexForDetailTemplate = true) {
-        if (!isDocumentAvailable()) {
-            return;
-        }
-        if (isPresent(this.detailTemplate) && adjustIndexForDetailTemplate) {
-            itemIndex = Math.floor(itemIndex / 2);
-        }
-        const offset = this.rowHeightService.offset(itemIndex);
-        this.container.nativeElement.scrollTop = offset;
-        this.scrollToIndex = itemIndex;
-    }
-    scrollTo({ row, column }, adjustIndex = false) {
-        if (isNumber(row)) {
-            if (this.isVirtual) {
-                this.scrollToVirtualRow(row, adjustIndex);
-            }
-            else {
-                const element = rowAt(row, this.table.nativeElement.rows);
-                if (element) {
-                    this.container.nativeElement.scrollTop = element.offsetTop;
-                }
-            }
-        }
-        if (isNumber(column)) {
-            column -= this.lockedLeafColumns.length;
-            if (this.virtualColumns) {
-                const columns = this.columns.leafColumnsToRender;
-                let offset = 0;
-                for (let idx = 0; idx < column; idx++) {
-                    offset += columns[idx].width || 0;
-                }
-                const startOffset = this.lockedLeafColumns.length ? 0 : this.groups.length * GROUP_CELL_WIDTH + (this.detailTemplate && column > 0 ? GROUP_CELL_WIDTH : 0);
-                this.container.nativeElement.scrollLeft = this.normalizeScrollLeft(offset + startOffset);
-            }
-            else if (column === 0 && this.detailTemplate) {
-                this.container.nativeElement.scrollLeft = this.normalizeScrollLeft(0);
-            }
-            else {
-                const firstRow = rowAt(0, this.table.nativeElement.rows);
-                if (firstRow) {
-                    const element = cellAt(column, firstRow.cells);
-                    if (element) {
-                        this.container.nativeElement.scrollLeft = this.elementScrollLeft(element);
-                    }
-                }
-            }
-        }
-    }
-    scrollToItem(item) {
-        if (!isDocumentAvailable()) {
-            return;
-        }
-        const data = this.ctx.grid.data;
-        const gridData = Array.isArray(data) ? data : data.data;
-        const gridDataItems = gridData.flatMap(recursiveFlatMap);
-        const dataItemIndex = gridDataItems.findIndex(dataItem => dataItem[item.idField] === item.id);
-        if (dataItemIndex !== -1) {
-            const row = Array.from(this.table.nativeElement.rows).find((r) => {
-                const dataAttribute = r.getAttribute('data-kendo-grid-item-index');
-                return dataAttribute && +dataAttribute === this.ctx.grid.skip + dataItemIndex;
-            });
-            row && row.scrollIntoView();
-            this.resetNavigationViewport();
-        }
-    }
-    cleanupScroller() {
-        if (this.scrollerSubscription) {
-            this.scrollerSubscription.unsubscribe();
-        }
-        if (this.scroller) {
-            this.scroller.destroy();
-        }
-    }
-    initResizeService() {
-        this.resizeService.connect(merge(...this.resizeSensors.map(sensor => sensor.resize)));
-    }
-    syncContainerHeight() {
-        [maybeNativeElement(this.lockedContainer)]
-            .filter(isPresent)
-            .map(el => {
-            el.style.height = '';
-            let height = this.container.nativeElement.offsetHeight;
-            if (hasScrollbar(this.table, this.container)) {
-                height -= this.supportService.scrollbarWidth;
-            }
-            return { el, height };
-        })
-            .forEach(setHeight(this.renderer));
-    }
-    handleColumnScroll() {
-        const container = this.container.nativeElement;
-        const scrollLeft = container.scrollLeft;
-        if (this.scrollLeft !== scrollLeft) {
-            this.scrollLeft = scrollLeft;
-            const range = this.calculateViewportColumns();
-            this.updateColumnViewport(range.startIdx, range.endIdx);
-            if (range.startIdx < this.columnsStartIdx || this.columnsEndIdx < range.endIdx) {
-                cancelAnimationFrame(this.columnUpdateFrame);
-                this.columnUpdateFrame = requestAnimationFrame(() => {
-                    this.ngZone.run(() => {
-                        this.updateViewportColumns(range);
-                        this.changeDetector.markForCheck();
-                    });
-                });
-            }
-        }
-    }
-    updateColumnViewport(startIdx, endIdx) {
-        const lockedCount = this.lockedLeafColumns.length;
-        const leafColumns = this.nonLockedLeafColumns.toArray();
-        const viewportStart = lockedCount + startIdx + (this.detailTemplate && startIdx > 0 ? 1 : 0);
-        let viewportEnd = lockedCount + endIdx + (this.detailTemplate ? 1 : 0);
-        for (let idx = 0; idx < leafColumns.length; idx++) {
-            const column = leafColumns[idx];
-            if (column.isSpanColumn) {
-                viewportEnd += column.children.length;
-            }
-        }
-        this.navigationService.setColumnViewport(viewportStart, viewportEnd);
-    }
-    calculateViewportColumns() {
-        const { scrollLeft, clientWidth } = this.container.nativeElement;
-        const columns = this.columns.nonLockedLeafColumns.toArray();
-        const normalizedScrollLeft = this.normalizeScrollLeft(scrollLeft);
-        const viewportEnd = normalizedScrollLeft + clientWidth;
-        let startIdx;
-        let endIdx = 0;
-        let current = 0;
-        let offset = 0;
-        let idx;
-        for (idx = 0; idx < columns.length; idx++) {
-            const column = columns[idx];
-            current += column.width || 0;
-            if (startIdx === undefined && current > normalizedScrollLeft) {
-                startIdx = idx;
-                offset = current - (column.width || 0);
-            }
-            if (current >= viewportEnd) {
-                endIdx = idx;
-                break;
-            }
-        }
-        if (!endIdx && idx > 0) {
-            endIdx = columns.length - 1;
-        }
-        return { startIdx, endIdx, offset };
-    }
-    viewportWidthChange() {
-        const currentWidth = this.viewportColumns.toArray().reduce((total, column) => total + column.width, 0);
-        return currentWidth !== this.viewportColumnsWidth;
-    }
-    normalizeScrollLeft(position) {
-        return this.rtl ? rtlScrollPosition(position, this.container.nativeElement, this.supportService.rtlScrollLeft) : position;
-    }
-    elementScrollLeft(element) {
-        if (this.rtl) {
-            return this.normalizeScrollLeft(this.container.nativeElement.scrollWidth - element.offsetLeft - element.offsetWidth);
-        }
-        return element.offsetLeft;
-    }
-    calcVirtualPageSize = () => {
-        const containerHeight = this.container.nativeElement.offsetHeight;
-        if (containerHeight && (this.rowHeight ?? this.minRowHeight)) {
-            return Math.ceil((containerHeight / (this.rowHeight ?? this.minRowHeight)) * 1.5);
-        }
-        return 0;
-    };
-    setScrollerOptions() {
-        this.scroller.scrollableVirtual = this.isVirtual;
-        this.scroller.table = this.table.nativeElement;
-        this.scroller.lockedTable = this.lockedTable?.nativeElement || null;
-        this.scroller.tableBody = this.table.nativeElement.tBodies[0];
-        this.scroller.container = this.container.nativeElement;
-        this.scroller.scrollHeightContainer = this.container.nativeElement.querySelector('.k-height-container');
-        this.scroller.total = this.isVirtual && !this.ctx.grid?.pageable ? this.total : this.allItems.length;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ListComponent, deps: [{ token: SCROLLER_FACTORY_TOKEN }, { token: i1.DetailsService }, { token: i2.ChangeNotificationService }, { token: i3.SuspendService }, { token: i4.GroupsService }, { token: i0.NgZone }, { token: i0.Renderer2 }, { token: i5.ScrollSyncService }, { token: i6.ResizeService }, { token: i7.EditService }, { token: i8.BrowserSupportService }, { token: i9.NavigationService }, { token: i10.ScrollRequestService }, { token: i11.ContextService }, { token: i12.ColumnResizingService }, { token: i0.ChangeDetectorRef }, { token: i13.PDFService }, { token: i14.ColumnInfoService }, { token: i15.DataMappingService }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: ListComponent, isStandalone: true, selector: "kendo-grid-list", inputs: { data: "data", groups: "groups", total: "total", rowHeight: "rowHeight", detailRowHeight: "detailRowHeight", take: "take", skip: "skip", columns: "columns", detailTemplate: "detailTemplate", noRecordsTemplate: "noRecordsTemplate", selectable: "selectable", groupable: "groupable", filterable: "filterable", rowClass: "rowClass", rowSticky: "rowSticky", loading: "loading", trackBy: "trackBy", virtualColumns: "virtualColumns", isVirtual: "isVirtual", cellLoadingTemplate: "cellLoadingTemplate", loadingTemplate: "loadingTemplate", sort: "sort", size: "size" }, outputs: { contentScroll: "contentScroll", pageChange: "pageChange", scrollBottom: "scrollBottom" }, host: { properties: { "class.k-grid-container": "this.hostClass", "attr.role": "this.hostRole" } }, providers: [
-            {
-                provide: SCROLLER_FACTORY_TOKEN,
-                useValue: DEFAULT_SCROLLER_FACTORY
-            }
-        ], viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true, static: true }, { propertyName: "lockedContainer", first: true, predicate: ["lockedContainer"], descendants: true }, { propertyName: "lockedTable", first: true, predicate: ["lockedTable"], descendants: true }, { propertyName: "table", first: true, predicate: ["table"], descendants: true, static: true }, { propertyName: "resizeSensors", predicate: ResizeSensorComponent, descendants: true }], usesOnChanges: true, ngImport: i0, template: `
-    @if (isLocked && !isStacked) {
-      <div #lockedContainer class="k-grid-content-locked" role="presentation"
-        [style.width.px]="lockedWidth" tabindex="-1"
-        [kendoEventsOutsideAngular]="{
-            keydown: lockedKeydown,
-            scroll: lockedScroll,
-            mousewheel: lockedMousewheel,
-            DOMMouseScroll: lockedMousewheel
-        }"
-        [scope]="this"
-        >
-        <div role="presentation">
-          <table
-            kendoGridResizableTable
-            [locked]="true"
-            #lockedTable
-            class="k-grid-table"
-            role="presentation"
-            kendoGridTable
-            [size]="size"
-            [style.width.px]="lockedWidth">
-            <colgroup kendoGridColGroup
-              [groups]="groups"
-              [columns]="$any(lockedLeafColumns)"
-              [detailTemplate]="detailTemplate"
-              [sort]="sort">
-          </colgroup>
-          <tbody kendoGridTableBody
-            role="presentation"
-            [groups]="groups"
-            [isLocked]="true"
-            [rowsToRender]="itemsToRender"
-            [rowHeight]="rowHeight"
-            [detailRowHeight]="detailRowHeight"
-            [noRecordsText]="''"
-            [columns]="$any(lockedLeafColumns)"
-            [totalColumnsCount]="leafColumns.length"
-            [totalColumns]="columns"
-            [detailTemplate]="detailTemplate"
-            [skip]="skip"
-            [selectable]="selectable"
-            [trackBy]="trackBy"
-            [filterable]="filterable"
-            [rowClass]="rowClass"
-            [isLoading]="loading"
-            [isVirtual]="isVirtual"
-            [cellLoadingTemplate]="cellLoadingTemplate">
-          </tbody>
-        </table>
-        <kendo-resize-sensor></kendo-resize-sensor>
-      </div>
-      @if (isVirtual) {
-        <div class="k-height-container" role="presentation">
-          <div></div>
-        </div>
-      }
-    </div>
-    }
-    <div
-      #container
-      class="k-grid-content k-virtual-content"
-      [kendoGridResizableContainer]="lockedLeafColumns.length > 0"
-      [lockedWidth]="lockedWidth + 1"
-      tabindex="-1"
-      >
-      <div role="presentation">
-        <table
-          [style.width.px]="nonLockedWidth"
-          #table
-          kendoGridResizableTable
-          [virtualColumns]="virtualColumns"
-          class="k-grid-table"
-          kendoGridTable
-          [size]="size"
-          role="presentation">
-          <colgroup kendoGridColGroup
-            [groups]="isLocked ? [] : groups"
-            [columns]="$any(nonLockedColumnsToRender)"
-            [detailTemplate]="detailTemplate"
-            [sort]="sort">
-        </colgroup>
-        <tbody kendoGridTableBody
-          role="rowgroup"
-          [skipGroupDecoration]="isLocked"
-          [rowsToRender]="itemsToRender"
-          [groups]="groups"
-          [columns]="$any(nonLockedColumnsToRender)"
-          [allColumns]="$any(nonLockedLeafColumns)"
-          [detailTemplate]="detailTemplate"
-          [noRecordsTemplate]="noRecordsTemplate"
-          [lockedColumnsCount]="lockedLeafColumns.length"
-          [totalColumnsCount]="leafColumns.length"
-          [totalColumns]="columns"
-          [skip]="skip"
-          [selectable]="selectable"
-          [trackBy]="trackBy"
-          [filterable]="filterable"
-          [rowClass]="rowClass"
-          [rowSticky]="rowSticky"
-          [virtualColumns]="virtualColumns"
-          [isLoading]="loading"
-          [isVirtual]="isVirtual"
-          [cellLoadingTemplate]="cellLoadingTemplate"
-          [rowHeight]="rowHeight"
-          [detailRowHeight]="detailRowHeight">
-        </tbody>
-      </table>
-      @if (isLocked) {
-        <kendo-resize-sensor></kendo-resize-sensor>
-      }
-    </div>
-    @if (isLocked || virtualColumns) {
-      <kendo-resize-sensor></kendo-resize-sensor>
-    }
-    @if (isVirtual) {
-      <div class="k-height-container" role="presentation">
-        <div></div>
-      </div>
-    }
-    @if (virtualColumns && !isStacked) {
-      <div class="k-width-container" role="presentation">
-        <div [style.width.px]="totalWidth"></div>
-      </div>
-    }
-    </div>
-    `, isInline: true, dependencies: [{ kind: "directive", type: EventsOutsideAngularDirective, selector: "[kendoEventsOutsideAngular]", inputs: ["kendoEventsOutsideAngular", "scope"] }, { kind: "directive", type: TableDirective, selector: "[kendoGridResizableTable]", inputs: ["locked", "virtualColumns"] }, { kind: "directive", type: GridTableDirective, selector: "[kendoGridTable]", inputs: ["size"] }, { kind: "component", type: ColGroupComponent, selector: "[kendoGridColGroup]", inputs: ["columns", "groups", "detailTemplate", "sort"] }, { kind: "component", type: TableBodyComponent, selector: "[kendoGridTableBody]", inputs: ["columns", "allColumns", "groups", "detailTemplate", "noRecordsTemplate", "rowsToRender", "skip", "selectable", "filterable", "noRecordsText", "isLocked", "isLoading", "isVirtual", "cellLoadingTemplate", "skipGroupDecoration", "lockedColumnsCount", "totalColumnsCount", "virtualColumns", "trackBy", "rowSticky", "totalColumns", "rowClass", "rowHeight", "detailRowHeight"] }, { kind: "component", type: ResizeSensorComponent, selector: "kendo-resize-sensor", inputs: ["rateLimit"], outputs: ["resize"] }, { kind: "directive", type: ResizableContainerDirective, selector: "[kendoGridResizableContainer]", inputs: ["lockedWidth", "kendoGridResizableContainer"] }] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ListComponent, decorators: [{
-            type: Component,
-            args: [{
-                    providers: [
-                        {
-                            provide: SCROLLER_FACTORY_TOKEN,
-                            useValue: DEFAULT_SCROLLER_FACTORY
-                        }
-                    ],
-                    selector: 'kendo-grid-list',
-                    template: `
-    @if (isLocked && !isStacked) {
-      <div #lockedContainer class="k-grid-content-locked" role="presentation"
-        [style.width.px]="lockedWidth" tabindex="-1"
-        [kendoEventsOutsideAngular]="{
-            keydown: lockedKeydown,
-            scroll: lockedScroll,
-            mousewheel: lockedMousewheel,
-            DOMMouseScroll: lockedMousewheel
-        }"
-        [scope]="this"
-        >
-        <div role="presentation">
-          <table
-            kendoGridResizableTable
-            [locked]="true"
-            #lockedTable
-            class="k-grid-table"
-            role="presentation"
-            kendoGridTable
-            [size]="size"
-            [style.width.px]="lockedWidth">
-            <colgroup kendoGridColGroup
-              [groups]="groups"
-              [columns]="$any(lockedLeafColumns)"
-              [detailTemplate]="detailTemplate"
-              [sort]="sort">
-          </colgroup>
-          <tbody kendoGridTableBody
-            role="presentation"
-            [groups]="groups"
-            [isLocked]="true"
-            [rowsToRender]="itemsToRender"
-            [rowHeight]="rowHeight"
-            [detailRowHeight]="detailRowHeight"
-            [noRecordsText]="''"
-            [columns]="$any(lockedLeafColumns)"
-            [totalColumnsCount]="leafColumns.length"
-            [totalColumns]="columns"
-            [detailTemplate]="detailTemplate"
-            [skip]="skip"
-            [selectable]="selectable"
-            [trackBy]="trackBy"
-            [filterable]="filterable"
-            [rowClass]="rowClass"
-            [isLoading]="loading"
-            [isVirtual]="isVirtual"
-            [cellLoadingTemplate]="cellLoadingTemplate">
-          </tbody>
-        </table>
-        <kendo-resize-sensor></kendo-resize-sensor>
-      </div>
-      @if (isVirtual) {
-        <div class="k-height-container" role="presentation">
-          <div></div>
-        </div>
-      }
-    </div>
-    }
-    <div
-      #container
-      class="k-grid-content k-virtual-content"
-      [kendoGridResizableContainer]="lockedLeafColumns.length > 0"
-      [lockedWidth]="lockedWidth + 1"
-      tabindex="-1"
-      >
-      <div role="presentation">
-        <table
-          [style.width.px]="nonLockedWidth"
-          #table
-          kendoGridResizableTable
-          [virtualColumns]="virtualColumns"
-          class="k-grid-table"
-          kendoGridTable
-          [size]="size"
-          role="presentation">
-          <colgroup kendoGridColGroup
-            [groups]="isLocked ? [] : groups"
-            [columns]="$any(nonLockedColumnsToRender)"
-            [detailTemplate]="detailTemplate"
-            [sort]="sort">
-        </colgroup>
-        <tbody kendoGridTableBody
-          role="rowgroup"
-          [skipGroupDecoration]="isLocked"
-          [rowsToRender]="itemsToRender"
-          [groups]="groups"
-          [columns]="$any(nonLockedColumnsToRender)"
-          [allColumns]="$any(nonLockedLeafColumns)"
-          [detailTemplate]="detailTemplate"
-          [noRecordsTemplate]="noRecordsTemplate"
-          [lockedColumnsCount]="lockedLeafColumns.length"
-          [totalColumnsCount]="leafColumns.length"
-          [totalColumns]="columns"
-          [skip]="skip"
-          [selectable]="selectable"
-          [trackBy]="trackBy"
-          [filterable]="filterable"
-          [rowClass]="rowClass"
-          [rowSticky]="rowSticky"
-          [virtualColumns]="virtualColumns"
-          [isLoading]="loading"
-          [isVirtual]="isVirtual"
-          [cellLoadingTemplate]="cellLoadingTemplate"
-          [rowHeight]="rowHeight"
-          [detailRowHeight]="detailRowHeight">
-        </tbody>
-      </table>
-      @if (isLocked) {
-        <kendo-resize-sensor></kendo-resize-sensor>
-      }
-    </div>
-    @if (isLocked || virtualColumns) {
-      <kendo-resize-sensor></kendo-resize-sensor>
-    }
-    @if (isVirtual) {
-      <div class="k-height-container" role="presentation">
-        <div></div>
-      </div>
-    }
-    @if (virtualColumns && !isStacked) {
-      <div class="k-width-container" role="presentation">
-        <div [style.width.px]="totalWidth"></div>
-      </div>
-    }
-    </div>
-    `,
-                    standalone: true,
-                    imports: [EventsOutsideAngularDirective, TableDirective, GridTableDirective, ColGroupComponent, TableBodyComponent, ResizeSensorComponent, ResizableContainerDirective]
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [SCROLLER_FACTORY_TOKEN]
-                }] }, { type: i1.DetailsService }, { type: i2.ChangeNotificationService }, { type: i3.SuspendService }, { type: i4.GroupsService }, { type: i0.NgZone }, { type: i0.Renderer2 }, { type: i5.ScrollSyncService }, { type: i6.ResizeService }, { type: i7.EditService }, { type: i8.BrowserSupportService }, { type: i9.NavigationService }, { type: i10.ScrollRequestService }, { type: i11.ContextService }, { type: i12.ColumnResizingService }, { type: i0.ChangeDetectorRef }, { type: i13.PDFService }, { type: i14.ColumnInfoService }, { type: i15.DataMappingService }], propDecorators: { hostClass: [{
-                type: HostBinding,
-                args: ['class.k-grid-container']
-            }], hostRole: [{
-                type: HostBinding,
-                args: ['attr.role']
-            }], data: [{
-                type: Input
-            }], groups: [{
-                type: Input
-            }], total: [{
-                type: Input
-            }], rowHeight: [{
-                type: Input
-            }], detailRowHeight: [{
-                type: Input
-            }], take: [{
-                type: Input
-            }], skip: [{
-                type: Input
-            }], columns: [{
-                type: Input
-            }], detailTemplate: [{
-                type: Input
-            }], noRecordsTemplate: [{
-                type: Input
-            }], selectable: [{
-                type: Input
-            }], groupable: [{
-                type: Input
-            }], filterable: [{
-                type: Input
-            }], rowClass: [{
-                type: Input
-            }], rowSticky: [{
-                type: Input
-            }], loading: [{
-                type: Input
-            }], trackBy: [{
-                type: Input
-            }], virtualColumns: [{
-                type: Input
-            }], isVirtual: [{
-                type: Input
-            }], cellLoadingTemplate: [{
-                type: Input
-            }], loadingTemplate: [{
-                type: Input
-            }], sort: [{
-                type: Input
-            }], size: [{
-                type: Input
-            }], contentScroll: [{
-                type: Output
-            }], pageChange: [{
-                type: Output
-            }], scrollBottom: [{
-                type: Output
-            }], container: [{
-                type: ViewChild,
-                args: ['container', { static: true }]
-            }], lockedContainer: [{
-                type: ViewChild,
-                args: ['lockedContainer']
-            }], lockedTable: [{
-                type: ViewChild,
-                args: ['lockedTable']
-            }], table: [{
-                type: ViewChild,
-                args: ['table', { static: true }]
-            }], resizeSensors: [{
-                type: ViewChildren,
-                args: [ResizeSensorComponent]
-            }] } });