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

package/esm2022/selection/selection.service.mjs

@@ -1,466 +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 } from '../utils';
-import { isPresent, isMultipleRangesEnabled } from '../utils';
-import { DomEventsService } from '../common/dom-events.service';
-import { LocalDataChangesService } from '../editing/local-data-changes.service';
-import { NavigationService } from '../navigation/navigation.service';
-import { ContextService } from '../common/provider.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";
-import * as i5 from "../common/provider.service";
-/**
- * @hidden
- */
-export class SelectionService {
-    domEvents;
-    aggregateService;
-    localDataChangesService;
-    navigationService;
-    ctxService;
-    changes = new EventEmitter();
-    lastSelectionStartIndex;
-    currentSelection = [];
-    nonSelectableRows = new Map();
-    selectAllChecked = false;
-    settings;
-    active = false;
-    aggregates;
-    get enableMarquee() {
-        const checkboxOnly = this.settings && typeof this.settings === 'object' && this.settings.checkboxOnly;
-        if (!this.settings || checkboxOnly) {
-            return false;
-        }
-        const selectableSettings = this.settings.selectable;
-        const dragAndMultiple = typeof (selectableSettings) === 'object' &&
-            isPresent(selectableSettings) &&
-            selectableSettings.mode === 'multiple' &&
-            selectableSettings.enabled !== false &&
-            !selectableSettings.checkboxOnly &&
-            selectableSettings.drag;
-        return this.active && dragAndMultiple;
-    }
-    mouseDownEventArgs;
-    dragging = false;
-    get hasNonSelectable() {
-        return this.nonSelectableRows.size > 0;
-    }
-    cellClickSubscription;
-    mousedownSubscription;
-    dataChangedSubscription;
-    lastSelectionData = {};
-    _selectAllState;
-    constructor(domEvents, aggregateService, localDataChangesService, navigationService, ctxService) {
-        this.domEvents = domEvents;
-        this.aggregateService = aggregateService;
-        this.localDataChangesService = localDataChangesService;
-        this.navigationService = navigationService;
-        this.ctxService = ctxService;
-        this.addSubscriptions();
-    }
-    init(settings) {
-        this.settings = settings;
-        if (!isPresent(this.lastSelectionStartIndex)) {
-            this.lastSelectionStartIndex = this.ctxService?.grid.selectionDirective?.rangeSelectionStartRow?.index || 0;
-            this.lastSelectionData = this.ctxService?.grid.selectionDirective?.rangeSelectionStartRow?.dataItem || {};
-        }
-        this.currentSelection = [];
-        this.nonSelectableRows = new Map();
-        if (settings.selectable && settings.selectable.enabled !== false) {
-            const iterator = this.getIterator();
-            this._selectAllState = true;
-            let item = iterator.next();
-            while (!item.done) {
-                if (item.value && item.value.type === "data") {
-                    const rowArgs = {
-                        dataItem: item.value.data,
-                        index: item.value.index
-                    };
-                    if (settings.rowSelected(rowArgs)) {
-                        this.currentSelection[item.value.index] = rowArgs;
-                    }
-                    else {
-                        this._selectAllState = undefined;
-                    }
-                    if (!settings.isRowSelectable(rowArgs)) {
-                        this.nonSelectableRows.set(rowArgs.index, rowArgs.dataItem);
-                        this._selectAllState = undefined;
-                    }
-                }
-                item = iterator.next();
-            }
-            if (this.currentSelection.length === 0) {
-                this._selectAllState = false;
-            }
-        }
-    }
-    isSelected(index) {
-        if (this.settings && this.active) {
-            return this.options.enabled && isPresent(this.currentSelection[index]) && !this.nonSelectableRows.has(index);
-        }
-    }
-    handleClick(item, event) {
-        if (this.dragging) {
-            this.dragging = false;
-            return;
-        }
-        let ev;
-        const ctrlKey = event.ctrlKey || event.metaKey;
-        if (this.options.mode === "single" && ctrlKey && this.isSelected(item.index)) {
-            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 preserveCurrentSelection = isMultipleRangesEnabled(this.settings);
-                ev = this.addAllTo(item, ctrlKey, preserveCurrentSelection);
-            }
-        }
-        if (!isPresent(ev)) {
-            ev = this.select(item);
-            this.currentSelection[item.index] = {
-                dataItem: item.data,
-                index: item.index
-            };
-        }
-        if (!ev.selectedRows.length && !ev.deselectedRows.length) {
-            return;
-        }
-        ev.ctrlKey = ctrlKey;
-        ev.shiftKey = event.shiftKey;
-        if (this.options.cellAggregates) {
-            ev.cellAggregates = this.aggregateService.onSelectionChange(ev);
-        }
-        if (ev.shiftKey) {
-            ev.rangeStartRow = { dataItem: this.lastSelectionData, index: this.lastSelectionStartIndex };
-            ev.rangeEndRow = { dataItem: item.data, index: item.index };
-            this.lastSelectionData = item.data;
-            this.lastSelectionStartIndex = item.index;
-        }
-        this.syncCurrentSelection(ev);
-        this.changes.emit(ev);
-    }
-    toggle(item) {
-        const selectedRows = [];
-        const deselectedRows = [];
-        this.lastSelectionStartIndex = item.index;
-        this.lastSelectionData = item.data;
-        const rowArgs = { dataItem: item.data, index: item.index };
-        if (this.isSelected(item.index)) {
-            deselectedRows.push(rowArgs);
-        }
-        else if (!this.nonSelectableRows.has(item.index)) {
-            selectedRows.push(rowArgs);
-        }
-        if (this.hasNonSelectable) {
-            const nonSelectableRows = this.currentSelection.filter(i => this.nonSelectableRows.has(i.index));
-            deselectedRows.push(...nonSelectableRows);
-        }
-        return {
-            deselectedRows: deselectedRows,
-            selectedRows: selectedRows
-        };
-    }
-    toggleByIndex(index) {
-        const iterator = this.getIterator();
-        if (this.selectAllChecked && this.isSelected(index)) {
-            this.selectAllChecked = false;
-        }
-        let item = iterator.next();
-        while (!item.done) {
-            if (item.value && item.value.type === "data" && item.value.index === index) {
-                const itemToToggle = {
-                    data: item.value.data,
-                    index: item.value.index
-                };
-                if (this.isSelected(index) || this.options.mode === "multiple") {
-                    return this.toggle(itemToToggle);
-                }
-                else {
-                    return this.select(itemToToggle);
-                }
-            }
-            item = iterator.next();
-        }
-    }
-    select(item) {
-        const deselectedRows = [];
-        const selectedRows = [];
-        this.lastSelectionStartIndex = item.index;
-        this.lastSelectionData = item.data;
-        if (!this.isSelected(item.index) && !this.nonSelectableRows.has(item.index)) {
-            selectedRows.push({ dataItem: item.data, index: item.index });
-        }
-        this.currentSelection.forEach((row) => {
-            if (row.index !== item.index) {
-                deselectedRows.push(row);
-            }
-        });
-        return {
-            deselectedRows: deselectedRows,
-            selectedRows: selectedRows
-        };
-    }
-    //Used to manually deselect removed items
-    deselect(removedItem) {
-        const iterator = this.getIterator();
-        let item = iterator.next();
-        while (!item.done) {
-            if (item.value && item.value.type === "data" && item.value.data === removedItem) {
-                const rowArgs = {
-                    dataItem: item.value.data,
-                    index: item.value.index
-                };
-                if (this.isSelected(rowArgs.index) || this.nonSelectableRows.has(rowArgs.index)) {
-                    const ev = {
-                        ctrlKey: false,
-                        deselectedRows: [rowArgs],
-                        selectedRows: []
-                    };
-                    this.syncCurrentSelection(ev);
-                    this.changes.emit(ev);
-                }
-            }
-            item = iterator.next();
-        }
-    }
-    addAllTo(item, ctrlKey, preserveSelection = false, shiftKey = false) {
-        const selectedRows = [];
-        const deselectedRows = [];
-        const start = Math.min(this.lastSelectionStartIndex, item.index);
-        const end = Math.max(this.lastSelectionStartIndex, item.index);
-        const iterator = this.getIterator();
-        let next = iterator.next();
-        let selectedItem;
-        while (!next.done) {
-            if (next.value && next.value.type === "data") {
-                const idx = next.value.index;
-                const rowArgs = { dataItem: next.value.data, index: idx };
-                if ((idx < start || idx > end) && this.isSelected(idx) && !ctrlKey && !preserveSelection) {
-                    deselectedRows.push(rowArgs);
-                }
-                if ((idx >= start && idx <= end) && !this.isSelected(idx) && !this.nonSelectableRows.has(idx)) {
-                    selectedRows.push(rowArgs);
-                }
-                if (idx === item.index && !this.nonSelectableRows.has(idx)) {
-                    selectedItem = rowArgs;
-                }
-            }
-            next = iterator.next();
-        }
-        if (this.hasNonSelectable) {
-            const nonSelectableRows = this.currentSelection.filter(i => this.nonSelectableRows.has(i.index));
-            deselectedRows.push(...nonSelectableRows);
-        }
-        const selectionEvent = {
-            deselectedRows,
-            selectedRows
-        };
-        if (shiftKey && selectedItem) {
-            selectionEvent.rangeStartRow = {
-                dataItem: this.lastSelectionData,
-                index: this.lastSelectionStartIndex
-            };
-            selectionEvent.rangeEndRow = {
-                dataItem: selectedItem.dataItem,
-                index: selectedItem.index
-            };
-            this.lastSelectionData = selectedItem.dataItem;
-            this.lastSelectionStartIndex = selectedItem.index;
-        }
-        return selectionEvent;
-    }
-    updateAll(selectAllChecked) {
-        this.selectAllChecked = selectAllChecked;
-        const selectedRows = [];
-        const deselectedRows = [];
-        const iterator = this.getIterator();
-        let next = iterator.next();
-        while (!next.done) {
-            if (next.value && next.value.type === "data") {
-                const idx = next.value.index;
-                const rowArgs = { dataItem: next.value.data, index: idx };
-                if (!this.nonSelectableRows.has(idx)) {
-                    if (this.isSelected(idx) && !selectAllChecked) {
-                        deselectedRows.push(rowArgs);
-                    }
-                    if (!this.isSelected(idx) && selectAllChecked) {
-                        selectedRows.push(rowArgs);
-                    }
-                }
-            }
-            next = iterator.next();
-        }
-        if (!selectedRows.length && !deselectedRows.length) {
-            return;
-        }
-        if (this.hasNonSelectable) {
-            const nonSelectableRows = this.currentSelection.filter(i => this.nonSelectableRows.has(i.index));
-            deselectedRows.push(...nonSelectableRows);
-        }
-        const ev = {
-            ctrlKey: true,
-            deselectedRows: deselectedRows,
-            selectedRows: selectedRows,
-            shiftKey: true
-        };
-        if (this.options.cellAggregates) {
-            ev.cellAggregates = this.aggregateService.onSelectionChange(ev);
-        }
-        this.syncCurrentSelection(ev);
-        this.changes.emit(ev);
-    }
-    selectRange(startIndex, endIndex, preserveSelection, existingSelections = []) {
-        const selectedRows = [];
-        const deselectedRows = [];
-        const start = Math.min(startIndex, endIndex);
-        const end = Math.max(startIndex, endIndex);
-        const iterator = this.getIterator();
-        let next = iterator.next();
-        while (!next.done) {
-            if (next.value && next.value.type === "data") {
-                const idx = next.value.index;
-                const rowArgs = { dataItem: next.value.data, index: idx };
-                if ((idx < start || idx > end) && this.isSelected(idx)) {
-                    const deselectRow = !(preserveSelection || existingSelections.find((value) => value && value.dataItem === rowArgs.dataItem && value.index === rowArgs.index));
-                    if (deselectRow) {
-                        deselectedRows.push(rowArgs);
-                    }
-                }
-                if ((idx >= start && idx <= end) && !this.isSelected(idx) && !this.nonSelectableRows.has(idx)) {
-                    selectedRows.push(rowArgs);
-                }
-            }
-            next = iterator.next();
-        }
-        let cellAggregates;
-        if (this.options.cellAggregates) {
-            cellAggregates = this.aggregateService.onSelectionChange({ selectedRows, deselectedRows });
-        }
-        if (this.hasNonSelectable) {
-            const nonSelectableRows = this.currentSelection.filter(i => this.nonSelectableRows.has(i.index));
-            deselectedRows.push(...nonSelectableRows);
-        }
-        return {
-            deselectedRows: deselectedRows,
-            selectedRows: selectedRows,
-            cellAggregates
-        };
-    }
-    get selectAllState() {
-        return this._selectAllState;
-    }
-    get selected() {
-        return this.currentSelection.map((item) => {
-            return item.index;
-        }).filter((n) => typeof n === "number");
-    }
-    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();
-    }
-    targetArgs() {
-        return {
-            index: this.mouseDownEventArgs.rowIndex,
-            dataItem: this.mouseDownEventArgs.dataItem
-        };
-    }
-    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 }, 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;
-        }
-    }
-    syncCurrentSelection(ev) {
-        for (const row of ev.deselectedRows) {
-            this.currentSelection.splice(row.index, 1);
-        }
-        for (const row of ev.selectedRows) {
-            this.currentSelection[row.index] = row;
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectionService, deps: [{ token: i1.DomEventsService }, { token: i2.CellSelectionAggregateService }, { token: i3.LocalDataChangesService }, { token: i4.NavigationService }, { token: i5.ContextService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectionService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectionService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.DomEventsService }, { type: i2.CellSelectionAggregateService }, { type: i3.LocalDataChangesService }, { type: i4.NavigationService }, { type: i5.ContextService }] });

package/esm2022/selection/types.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/state-management/grid-state.models.mjs

@@ -1,26 +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 { PreventableEvent } from "@progress/kendo-angular-common";
-/**
- * Provides arguments for the `undo` and `redo` events.
- */
-export class UndoRedoEvent extends PreventableEvent {
-    /**
-     * The event data for the action that changed the state.
-     */
-    originalEvent;
-    /**
-     * The Grid state and rendered data at the time of the action.
-     */
-    gridState;
-    /**
-     * @hidden
-     */
-    constructor({ originalEvent, gridState }) {
-        super();
-        this.originalEvent = originalEvent;
-        this.gridState = gridState;
-    }
-}

package/esm2022/state-management/redo-command-tool.mjs

@@ -1,74 +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 { Directive } from '@angular/core';
-import { ToolBarButtonComponent } from '@progress/kendo-angular-toolbar';
-import { Subscription } from 'rxjs';
-import { redoIcon } from '@progress/kendo-svg-icons';
-import { UndoRedoService } from './undo-redo.service';
-import * as i0 from "@angular/core";
-import * as i1 from "./undo-redo.service";
-import * as i2 from "@progress/kendo-angular-toolbar";
-/**
- * Represents the command that triggers the redo action in the Grid.
- * Apply this directive to any `kendo-toolbar-button` inside a ToolbarComponent in the Grid.
- *
- * When users click the toolbar button with this directive, the
- * [`redo`]({% slug api_grid_undoredodirective %}#toc-redo) event is triggered.
- *
- * @example
- * ```html
- * <kendo-grid>
- *      <kendo-toolbar>
- *         <kendo-toolbar-button kendoGridRedoTool></kendo-toolbar-button>
- *      </kendo-toolbar>
- * </kendo-grid>
- * ```
- */
-export class RedoCommandToolbarDirective {
-    undoRedoService;
-    host;
-    subs = new Subscription();
-    /**
-     * @hidden
-     */
-    constructor(undoRedoService, host) {
-        this.undoRedoService = undoRedoService;
-        this.host = host;
-    }
-    /**
-     * @hidden
-     */
-    ngOnInit() {
-        this.subs = this.host.click.subscribe((e) => this.onClick(e));
-        this.host.className = 'k-grid-redo-command';
-        this.host.svgIcon = redoIcon;
-        this.host.icon = 'redo';
-        this.host.text = 'Redo';
-        this.host.disabled = true;
-        this.subs.add(this.undoRedoService.stackEndReached.subscribe((stackEnd) => (this.host.disabled = stackEnd === 'end')));
-    }
-    /**
-     * @hidden
-     */
-    ngOnDestroy() {
-        this.subs.unsubscribe();
-    }
-    /**
-     * @hidden
-     */
-    onClick(e) {
-        e.preventDefault();
-        this.undoRedoService.onRedo.next(undefined);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RedoCommandToolbarDirective, deps: [{ token: i1.UndoRedoService }, { token: i2.ToolBarButtonComponent }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: RedoCommandToolbarDirective, isStandalone: true, selector: "[kendoGridRedoTool]", ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RedoCommandToolbarDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[kendoGridRedoTool]',
-                    standalone: true,
-                }]
-        }], ctorParameters: () => [{ type: i1.UndoRedoService }, { type: i2.ToolBarButtonComponent }] });

package/esm2022/state-management/undo-command-tool.mjs

@@ -1,74 +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 { Directive } from '@angular/core';
-import { ToolBarButtonComponent } from '@progress/kendo-angular-toolbar';
-import { Subscription } from 'rxjs';
-import { undoIcon } from '@progress/kendo-svg-icons';
-import { UndoRedoService } from './undo-redo.service';
-import * as i0 from "@angular/core";
-import * as i1 from "./undo-redo.service";
-import * as i2 from "@progress/kendo-angular-toolbar";
-/**
- * Represents the command that triggers the undo action in the Grid.
- * Apply this directive to any `kendo-toolbar-button` inside a ToolbarComponent in the Grid.
- *
- * When users click the toolbar button with this directive, the
- * [`undo`]({% slug api_grid_undoredodirective %}#toc-undo) event is triggered.
- *
- * @example
- * ```html
- * <kendo-grid>
- *      <kendo-toolbar>
- *         <kendo-toolbar-button kendoGridUndoTool></kendo-toolbar-button>
- *      </kendo-toolbar>
- * </kendo-grid>
- * ```
- */
-export class UndoCommandToolbarDirective {
-    undoRedoService;
-    host;
-    subs = new Subscription();
-    /**
-     * @hidden
-     */
-    constructor(undoRedoService, host) {
-        this.undoRedoService = undoRedoService;
-        this.host = host;
-    }
-    /**
-     * @hidden
-     */
-    ngOnInit() {
-        this.subs = this.host.click.subscribe((e) => this.onClick(e));
-        this.host.className = 'k-grid-undo-command';
-        this.host.svgIcon = undoIcon;
-        this.host.icon = 'undo';
-        this.host.text = 'Undo';
-        this.host.disabled = true;
-        this.subs.add(this.undoRedoService.stackEndReached.subscribe((stackEnd) => (this.host.disabled = stackEnd === 'start')));
-    }
-    /**
-     * @hidden
-     */
-    ngOnDestroy() {
-        this.subs.unsubscribe();
-    }
-    /**
-     * @hidden
-     */
-    onClick(e) {
-        e.preventDefault();
-        this.undoRedoService.onUndo.next(undefined);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UndoCommandToolbarDirective, deps: [{ token: i1.UndoRedoService }, { token: i2.ToolBarButtonComponent }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: UndoCommandToolbarDirective, isStandalone: true, selector: "[kendoGridUndoTool]", ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UndoCommandToolbarDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[kendoGridUndoTool]',
-                    standalone: true,
-                }]
-        }], ctorParameters: () => [{ type: i1.UndoRedoService }, { type: i2.ToolBarButtonComponent }] });