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

package/esm2022/scrolling/scroller.service.mjs

@@ -1,254 +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 { isFirefox, firefoxMaxHeight, isDocumentAvailable } from '@progress/kendo-angular-common';
-import { Observable, BehaviorSubject } from 'rxjs';
-/**
- * @hidden
- */
-export class ScrollAction {
-    offset;
-    changeVirtualData;
-    constructor(offset, changeVirtualData) {
-        this.offset = offset;
-        this.changeVirtualData = changeVirtualData;
-    }
-}
-/**
- * @hidden
- */
-export class PageAction {
-    skip;
-    take;
-    constructor(skip, take) {
-        this.skip = skip;
-        this.take = take;
-    }
-}
-/**
- * @hidden
- */
-export class ScrollBottomAction {
-}
-const SCROLL_BOTTOM_THRESHOLD = 2;
-/**
- * @hidden
- */
-export class ScrollerService {
-    scrollObservable;
-    ctx;
-    total = 0;
-    rowHeightService;
-    table = null;
-    lockedTable = null;
-    tableBody = null;
-    container = null;
-    scrollHeightContainer = null;
-    scrollableVirtual = false;
-    tableTransformOffset = 0;
-    virtualSkip = 0;
-    virtualPageSize = 0;
-    firstToLoad = 0;
-    lastLoaded = 0;
-    scrollSyncing = false;
-    scrollSubscription;
-    subscription;
-    lastScrollTop = 0;
-    firstLoaded = 0;
-    expandedRows = {};
-    take;
-    constructor(scrollObservable, ctx) {
-        this.scrollObservable = scrollObservable;
-        this.ctx = ctx;
-    }
-    create(rowHeightService, skip, take, total) {
-        this.rowHeightService = rowHeightService;
-        this.firstLoaded = skip;
-        this.lastLoaded = skip + take;
-        this.take = take;
-        this.total = total;
-        this.lastScrollTop = 0;
-        const offset = this.rowHeightService.offset(skip);
-        const subject = new BehaviorSubject(new ScrollAction(offset, this.scrollableVirtual && (Boolean(this.ctx.grid?.pageable) || Boolean(this.ctx.grid?.group?.length))));
-        this.subscription = Observable.create(observer => {
-            this.unsubscribe();
-            this.scrollSubscription = this.scrollObservable.subscribe(x => this.onScroll(x, observer));
-        }).subscribe(x => subject.next(x));
-        return subject;
-    }
-    reset(skipScroll = false) {
-        if (!skipScroll) {
-            this.firstToLoad = 0;
-            this.firstLoaded = 0;
-            this.lastLoaded = 0;
-            this.virtualSkip = 0;
-        }
-        this.rowHeightService = undefined;
-        if (skipScroll) {
-            this.scrollSyncing = true;
-        }
-        if (!skipScroll && this.container && this.container.scrollTop !== 0) {
-            this.scrollSyncing = true;
-            this.container.scrollTop = 0;
-            this.lastScrollTop = 0;
-            this.translate(0, true);
-            this.tableTransformOffset = 0;
-        }
-    }
-    update(skipAdjust = false) {
-        const itemHeights = this.getItemHeights();
-        if (this.firstLoaded > this.firstToLoad) {
-            // Scrolled up
-            const count = Math.min(this.firstLoaded - this.firstToLoad, this.take);
-            const newItemsHeight = this.getTotalHeight(count, itemHeights);
-            const newItemsExpectedHeight = this.getExpectedTotalHeight(count);
-            const diff = newItemsHeight - newItemsExpectedHeight;
-            if (!skipAdjust && diff !== 0) {
-                this.adjustScroll(diff);
-            }
-        }
-        this.rowHeightService?.update(this.firstToLoad, itemHeights);
-        this.scrollHeightContainer && this.setScrollHeightContainerHeight();
-        this.firstLoaded = this.firstToLoad;
-        this.lastLoaded = this.firstLoaded + itemHeights.length - 1;
-    }
-    destroy() {
-        this.unsubscribe();
-        if (this.subscription) {
-            this.subscription.unsubscribe();
-        }
-    }
-    onScroll({ scrollTop, offsetHeight, scrollHeight, clientHeight }, observer) {
-        if (this.scrollSyncing) {
-            this.scrollSyncing = false;
-            return;
-        }
-        if (!isDocumentAvailable() || (this.lastScrollTop === scrollTop)) {
-            return;
-        }
-        const up = this.lastScrollTop >= scrollTop;
-        const down = !up;
-        this.lastScrollTop = scrollTop;
-        let firstItemIndex = this.rowHeightService.index(scrollTop);
-        const lastItemIndex = this.rowHeightService.index(scrollTop + offsetHeight);
-        const overflow = Math.max(firstItemIndex + (this.virtualPageSize || this.take) - this.total, 0);
-        firstItemIndex = Math.max(firstItemIndex - overflow, 0);
-        if (down) {
-            const atBottom = scrollHeight - clientHeight - scrollTop < SCROLL_BOTTOM_THRESHOLD;
-            if (atBottom) {
-                observer.next(new ScrollBottomAction());
-            }
-        }
-        if (!this.scrollableVirtual) {
-            return;
-        }
-        if (down && lastItemIndex >= this.lastLoaded && this.lastLoaded < this.total - 1) {
-            this.firstToLoad = firstItemIndex;
-            this.loadPage(observer);
-        }
-        else if (up && firstItemIndex < this.firstLoaded) {
-            const nonVisibleBuffer = Math.max(Math.floor((this.virtualPageSize || this.take) * 0.3) - overflow, 0);
-            this.firstToLoad = Math.max(firstItemIndex - nonVisibleBuffer, 0);
-            this.loadPage(observer);
-        }
-    }
-    loadPage(observer) {
-        if (!this.rowHeightService) {
-            return;
-        }
-        this.translate(this.rowHeightService.offset(this.firstToLoad));
-        observer.next(new ScrollAction(this.rowHeightService.offset(this.firstToLoad)));
-        this.virtualPageChange(this.firstToLoad, observer);
-    }
-    unsubscribe() {
-        if (this.scrollSubscription) {
-            this.scrollSubscription.unsubscribe();
-            this.scrollSubscription = undefined;
-        }
-    }
-    translate(dY, forceSet) {
-        if (this.scrollableVirtual && this.table) {
-            if (forceSet) {
-                this.table.style.transform = 'translateY(' + dY + 'px)';
-                if (this.lockedTable) {
-                    this.lockedTable.style.transform = 'translateY(' + dY + 'px)';
-                }
-            }
-            else {
-                this.tableTransformOffset = dY;
-            }
-        }
-    }
-    adjustScroll(scrollOffset, initialAdjust = false) {
-        if (Number.isNaN(scrollOffset)) {
-            return;
-        }
-        this.scrollSyncing = true;
-        if (this.container) {
-            if (initialAdjust) {
-                this.container.scrollTop = scrollOffset;
-                this.translate(scrollOffset, true);
-                this.tableTransformOffset = scrollOffset;
-                this.firstToLoad = this.rowHeightService.index(scrollOffset);
-            }
-            else {
-                this.container.scrollTop += scrollOffset;
-            }
-        }
-    }
-    isExpanded(rowIndex) {
-        return this.expandedRows[rowIndex] || false;
-    }
-    resetVirtualSkip = () => {
-        if (this.scrollableVirtual && this.virtualSkip) {
-            this.virtualSkip = 0;
-        }
-    };
-    setScrollHeightContainerHeight() {
-        if (this.scrollableVirtual) {
-            let containerHeight = this.rowHeightService?.totalHeight() || 0;
-            containerHeight = isFirefox ? Math.min(firefoxMaxHeight, containerHeight) : containerHeight;
-            this.scrollHeightContainer.style.height = containerHeight + 'px';
-        }
-        else {
-            this.scrollHeightContainer.style.height = '0';
-        }
-    }
-    getItemHeights() {
-        const result = [];
-        if (this.tableBody) {
-            Array.from(this.tableBody.children).forEach((item, index) => {
-                const itemHeight = item.getBoundingClientRect().height;
-                if (item.classList.contains('k-detail-row')) {
-                    result[result.length - 1] += itemHeight;
-                    this.expandedRows[index] = true;
-                }
-                else {
-                    result.push(itemHeight);
-                }
-            });
-        }
-        return result;
-    }
-    getTotalHeight(count, itemHeights) {
-        return itemHeights.slice(0, count).reduce((sum, current) => sum + current, 0);
-    }
-    getExpectedTotalHeight(count) {
-        const service = this.rowHeightService;
-        if (!service) {
-            return 0;
-        }
-        const lastItemIndex = this.firstToLoad + (count - 1);
-        return service.offset(lastItemIndex) + service.height(lastItemIndex) - service.offset(this.firstToLoad);
-    }
-    virtualPageChange = (skip, observer) => {
-        if (this.ctx.grid.pageable || this.ctx.grid.group?.length) {
-            this.virtualSkip = skip;
-            observer.next(new ScrollAction(this.rowHeightService?.offset(skip) || 0, true));
-        }
-        else if (skip !== this.ctx.grid.skip) {
-            observer.next(new PageAction(Math.max(0, skip), this.take));
-        }
-    };
-}

package/esm2022/scrolling/scrollmode.mjs

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

package/esm2022/scrolling/suspend.service.mjs

@@ -1,17 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Injectable } from '@angular/core';
-import * as i0 from "@angular/core";
-/**
- * @hidden
- */
-export class SuspendService {
-    scroll = false;
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SuspendService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SuspendService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SuspendService, decorators: [{
-            type: Injectable
-        }] });

package/esm2022/selection/cell-selection.service.mjs

@@ -1,349 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Injectable, EventEmitter } from '@angular/core';
-import { iterator, isMultipleRangesEnabled } from '../utils';
-import { isPresent } from '../utils';
-import { DomEventsService } from '../common/dom-events.service';
-import { LocalDataChangesService } from '../editing/local-data-changes.service';
-import { NavigationService } from '../navigation/navigation.service';
-import { CellSelectionAggregateService } from '../aggregates/selection-aggregate.service';
-import * as i0 from "@angular/core";
-import * as i1 from "../common/dom-events.service";
-import * as i2 from "../aggregates/selection-aggregate.service";
-import * as i3 from "../editing/local-data-changes.service";
-import * as i4 from "../navigation/navigation.service";
-/**
- * @hidden
- */
-export class CellSelectionService {
-    domEvents;
-    aggregateService;
-    localDataChangesService;
-    navigationService;
-    changes = new EventEmitter();
-    mouseUpEvent = new EventEmitter();
-    currentSelection = [];
-    settings;
-    active = false;
-    aggregates;
-    nonSelectableRows = new Map();
-    get enableMarquee() {
-        const checkboxOnly = this.settings && typeof this.settings === 'object' && this.settings.checkboxOnly;
-        if (!this.settings || checkboxOnly || this.settings.isStacked) {
-            return false;
-        }
-        const selectableSettings = this.settings.selectable;
-        const dragAndMultiple = typeof (selectableSettings) === 'object' &&
-            isPresent(selectableSettings) &&
-            selectableSettings.mode === 'multiple' &&
-            selectableSettings.cell &&
-            selectableSettings.enabled !== false &&
-            selectableSettings.drag;
-        return this.active && dragAndMultiple;
-    }
-    get hasNonSelectable() {
-        return this.nonSelectableRows.size > 0;
-    }
-    mouseDownEventArgs;
-    mouseUpEventArgs;
-    dragging = false;
-    dragSelectDeselect = false;
-    lastSelectionItem = { itemKey: 0, columnKey: 0 };
-    lastSelectionItemRowIndex = 0;
-    lastSelectionItemColIndex = 0;
-    cellClickSubscription;
-    dataChangedSubscription;
-    mousedownSubscription;
-    constructor(domEvents, aggregateService, localDataChangesService, navigationService) {
-        this.domEvents = domEvents;
-        this.aggregateService = aggregateService;
-        this.localDataChangesService = localDataChangesService;
-        this.navigationService = navigationService;
-        this.addSubscriptions();
-    }
-    init(settings) {
-        this.settings = settings;
-        this.currentSelection = [];
-        this.nonSelectableRows = new Map();
-        if (settings.selectable && settings.selectable.enabled !== false && !settings.isStacked) {
-            const iterator = this.getIterator();
-            let item = iterator.next();
-            while (!item.done) {
-                if (item.value && item.value.type === "data") {
-                    const rowArgs = {
-                        dataItem: item.value.data,
-                        index: item.value.index
-                    };
-                    settings.columns.forEach(col => {
-                        const selectedCellArgs = settings.cellSelected(rowArgs, col, col.leafIndex);
-                        if (selectedCellArgs.selected) {
-                            this.currentSelection.push(selectedCellArgs.item);
-                        }
-                        if (!settings.isRowSelectable(rowArgs)) {
-                            this.nonSelectableRows.set(rowArgs.index, rowArgs.dataItem);
-                        }
-                    });
-                }
-                item = iterator.next();
-            }
-        }
-    }
-    isCellSelected(item, col) {
-        if (this.settings && this.active && !this.settings.isStacked) {
-            const selectedCellArgs = this.settings.cellSelected({ dataItem: item.data, index: item.index }, col, col.leafIndex);
-            return this.options.enabled && selectedCellArgs.selected && !this.nonSelectableRows.has(item.index);
-        }
-        return false;
-    }
-    handleClick(item, event) {
-        if (this.dragging) {
-            this.dragging = false;
-            return;
-        }
-        if (this.settings.isStacked) {
-            return;
-        }
-        let ev;
-        const ctrlKey = event.ctrlKey || event.metaKey;
-        if (this.options.mode === "single" && ctrlKey && this.isCellSelected(item, item.column)) {
-            ev = this.toggle(item);
-        }
-        else if (this.options.mode === "multiple") {
-            if ((ctrlKey || !this.options.metaKeyMultiSelect) && !event.shiftKey) {
-                ev = this.toggle(item);
-            }
-            else if (event.shiftKey) {
-                const startRowIndex = Math.min(this.lastSelectionItemRowIndex, item.index);
-                const startColIndex = Math.min(this.lastSelectionItemColIndex, item.column.leafIndex);
-                const endRowIndex = Math.max(this.lastSelectionItemRowIndex, item.index);
-                const endColIndex = Math.max(this.lastSelectionItemColIndex, item.column.leafIndex);
-                const preserveCurrentSelection = isMultipleRangesEnabled(this.settings);
-                ev = this.selectRange(startRowIndex, startColIndex, endRowIndex, endColIndex, preserveCurrentSelection);
-                if (preserveCurrentSelection) {
-                    this.lastSelectionItemRowIndex = item.index;
-                    this.lastSelectionItemColIndex = item.column.leafIndex;
-                }
-            }
-        }
-        if (!isPresent(ev)) {
-            ev = this.select(item);
-            this.currentSelection = [this.lastSelectionItem];
-        }
-        if (!ev.selectedCells.length && !ev.deselectedCells.length) {
-            return;
-        }
-        ev.ctrlKey = ctrlKey;
-        ev.shiftKey = event.shiftKey;
-        if (this.options.cellAggregates && !event.shiftKey) {
-            ev.cellAggregates = this.aggregateService.onSelectionChange(ev);
-        }
-        if (ev.shiftKey) {
-            ev.rangeStartCell = this.lastSelectionItem;
-            ev.rangeEndCell = {
-                ...this.settings.cellSelected({ dataItem: item.data, index: item.index }, item.column, item.column.leafIndex).item
-            };
-        }
-        this.changes.emit(ev);
-    }
-    toggle(item) {
-        const selectedCells = [];
-        const deselectedCells = [];
-        this.lastSelectionItem =
-            this.settings.cellSelected({ dataItem: item.data, index: item.index }, item.column, item.column.leafIndex).item;
-        this.lastSelectionItemRowIndex = item.index;
-        this.lastSelectionItemColIndex = item.column.leafIndex;
-        if (this.isCellSelected(item, item.column)) {
-            deselectedCells.push(this.lastSelectionItem);
-        }
-        else if (!this.nonSelectableRows.has(item.index)) {
-            selectedCells.push(this.lastSelectionItem);
-        }
-        return {
-            deselectedCells,
-            selectedCells
-        };
-    }
-    select(item) {
-        const selectedCells = [];
-        const deselectedCells = [];
-        this.lastSelectionItem =
-            this.settings.cellSelected({ dataItem: item.data, index: item.index }, item.column, item.column.leafIndex).item;
-        this.lastSelectionItemRowIndex = item.index;
-        this.lastSelectionItemColIndex = item.column.leafIndex;
-        if (!this.isCellSelected(item, item.column) && !this.nonSelectableRows.has(item.index)) {
-            selectedCells.push(this.lastSelectionItem);
-        }
-        this.currentSelection.forEach((selectedItem) => {
-            if (selectedItem.itemKey !== this.lastSelectionItem.itemKey || selectedItem.columnKey !== this.lastSelectionItem.columnKey) {
-                deselectedCells.push(selectedItem);
-            }
-        });
-        return {
-            deselectedCells,
-            selectedCells
-        };
-    }
-    //Used to manually deselect removed items
-    deselect(removedItem) {
-        const iterator = this.getIterator();
-        let item = iterator.next();
-        let rowArgs;
-        while (!item.done) {
-            if (item.value && item.value.type === "data" && item.value.data === removedItem) {
-                rowArgs = {
-                    dataItem: item.value.data,
-                    index: item.value.index
-                };
-                break;
-            }
-            item = iterator.next();
-        }
-        if (rowArgs) {
-            const cellsToRemove = this.currentSelection.filter(selectedItem => {
-                const contender = this.settings.cellSelected(rowArgs, null, null).item;
-                return selectedItem.itemKey === contender.itemKey || this.nonSelectableRows.has(rowArgs.index);
-            });
-            if (cellsToRemove.length) {
-                const ev = {
-                    ctrlKey: false,
-                    deselectedCells: cellsToRemove,
-                    selectedCells: []
-                };
-                this.changes.emit(ev);
-            }
-        }
-    }
-    selectRange(startRowIndex, startColIndex, endRowIndex, endColIndex, preserveSelection = false, existingSelections = []) {
-        const selectedCells = [];
-        const deselectedCells = [];
-        const selectionStartRow = Math.min(startRowIndex, endRowIndex);
-        const selectionStartCol = Math.min(startColIndex, endColIndex);
-        const selectionEndRow = Math.max(startRowIndex, endRowIndex);
-        const selectionEndCol = Math.max(startColIndex, endColIndex);
-        const iterator = this.getIterator();
-        let next = iterator.next();
-        while (!next.done) {
-            if (next.value && next.value.type === "data") {
-                const idx = next.value.index;
-                const data = next.value.data;
-                const rowArgs = {
-                    dataItem: data,
-                    index: idx
-                };
-                this.settings.columns.forEach(col => {
-                    const { item } = this.settings.cellSelected(rowArgs, col, col.leafIndex);
-                    const selected = this.isCellSelected(next.value, col);
-                    const isInRowRange = selectionStartRow <= idx && idx <= selectionEndRow;
-                    const isInColRange = selectionStartCol <= col.leafIndex && col.leafIndex <= selectionEndCol;
-                    const isInSelectionRect = isInRowRange && isInColRange;
-                    if (!isInSelectionRect && selected) {
-                        const deselectCell = !(preserveSelection || existingSelections.find((value) => value && value.itemKey === item.itemKey && value.columnKey === item.columnKey));
-                        if (deselectCell) {
-                            deselectedCells.push(item);
-                        }
-                    }
-                    if (isInSelectionRect && !selected && !this.nonSelectableRows.has(idx)) {
-                        selectedCells.push(item);
-                    }
-                });
-            }
-            next = iterator.next();
-        }
-        let cellAggregates;
-        if (this.options.cellAggregates) {
-            cellAggregates = this.aggregateService.onSelectionChange({ selectedCells, deselectedCells });
-        }
-        return {
-            deselectedCells,
-            selectedCells,
-            cellAggregates
-        };
-    }
-    get options() {
-        const defaultOptions = {
-            cellAggregates: false,
-            checkboxOnly: false,
-            enabled: true,
-            mode: "multiple",
-            metaKeyMultiSelect: true
-        };
-        if (!isPresent(this.settings)) {
-            return defaultOptions;
-        }
-        if (typeof this.settings.selectable === 'boolean') {
-            return {
-                cellAggregates: false,
-                checkboxOnly: false,
-                enabled: this.settings.selectable,
-                mode: "multiple",
-                metaKeyMultiSelect: true
-            };
-        }
-        else {
-            return Object.assign(defaultOptions, this.settings.selectable);
-        }
-    }
-    ngOnDestroy() {
-        this.removeSubscriptions();
-    }
-    addSubscriptions() {
-        if (!this.cellClickSubscription) {
-            this.cellClickSubscription = this.domEvents.cellClick.subscribe((args) => {
-                if (this.options.enabled && !this.options.checkboxOnly && args.type !== 'contextmenu') {
-                    if (this.active) {
-                        this.handleClick({ index: args.rowIndex, data: args.dataItem, column: args.column }, args.originalEvent);
-                    }
-                }
-            });
-        }
-        if (!this.mousedownSubscription) {
-            this.mousedownSubscription = this.domEvents.cellMousedown.subscribe((args) => {
-                this.mouseDownEventArgs = args;
-                if (this.options.enabled && (!this.options.mode || this.options.mode === "multiple") &&
-                    !this.options.checkboxOnly && args.originalEvent.shiftKey) {
-                    if (this.active) {
-                        args.originalEvent.preventDefault();
-                        this.navigationService.focusCellByElement(args.originalEvent.target);
-                    }
-                }
-            });
-        }
-        if (this.localDataChangesService && !this.dataChangedSubscription) {
-            this.dataChangedSubscription = this.localDataChangesService.changes.subscribe((args) => {
-                if (this.active) {
-                    if (isPresent(args.action) && args.action === 'remove') {
-                        this.deselect(args.item);
-                    }
-                }
-            });
-        }
-    }
-    getIterator() {
-        const accessor = this.settings.view.accessor();
-        if (!accessor) {
-            return;
-        }
-        return accessor[iterator]();
-    }
-    removeSubscriptions() {
-        if (this.cellClickSubscription) {
-            this.cellClickSubscription.unsubscribe();
-            this.cellClickSubscription = null;
-        }
-        if (this.mousedownSubscription) {
-            this.mousedownSubscription.unsubscribe();
-            this.mousedownSubscription = null;
-        }
-        if (this.dataChangedSubscription) {
-            this.dataChangedSubscription.unsubscribe();
-            this.dataChangedSubscription = null;
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CellSelectionService, deps: [{ token: i1.DomEventsService }, { token: i2.CellSelectionAggregateService }, { token: i3.LocalDataChangesService }, { token: i4.NavigationService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CellSelectionService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CellSelectionService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.DomEventsService }, { type: i2.CellSelectionAggregateService }, { type: i3.LocalDataChangesService }, { type: i4.NavigationService }] });