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

package/esm2022/selection/marquee.directive.mjs

@@ -1,188 +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 { DomEventsService } from './../common/dom-events.service';
-import { Directive, ElementRef, Renderer2 } from '@angular/core';
-import { DraggableDirective, isDocumentAvailable, isPresent } from '@progress/kendo-angular-common';
-import { SelectionService } from './selection.service';
-import { CellSelectionService } from './cell-selection.service';
-import { take, delay } from 'rxjs/operators';
-import { merge } from 'rxjs';
-import { isMultipleRangesEnabled } from '../utils';
-import * as i0 from "@angular/core";
-import * as i1 from "@progress/kendo-angular-common";
-import * as i2 from "./selection.service";
-import * as i3 from "./cell-selection.service";
-import * as i4 from "./../common/dom-events.service";
-const createElement = () => {
-    if (!isDocumentAvailable()) {
-        return;
-    }
-    const marquee = document.createElement("div");
-    marquee.className = "k-marquee";
-    const marqueeColor = document.createElement("div");
-    marqueeColor.className = "k-marquee-color";
-    marquee.appendChild(marqueeColor);
-    return marquee;
-};
-const POINTER_OFFSET = 2;
-const MINIMAL_DRAG_DISTANCE = 5;
-const offsets = {
-    topLeft: { x: POINTER_OFFSET, y: POINTER_OFFSET },
-    topRight: { x: -POINTER_OFFSET, y: POINTER_OFFSET },
-    bottomLeft: { x: POINTER_OFFSET, y: -POINTER_OFFSET },
-    bottomRight: { x: -POINTER_OFFSET, y: -POINTER_OFFSET }
-};
-/**
- * @hidden
- */
-export class GridMarqueeDirective {
-    draggable;
-    selection;
-    cellSelection;
-    domEvents;
-    host;
-    renderer;
-    // possibly add snap
-    pressArgs;
-    marqueeElement;
-    pressTarget;
-    subscriptions;
-    selectionStarted = false;
-    dragEndSubscription;
-    constructor(draggable, selection, cellSelection, domEvents, host, renderer) {
-        this.draggable = draggable;
-        this.selection = selection;
-        this.cellSelection = cellSelection;
-        this.domEvents = domEvents;
-        this.host = host;
-        this.renderer = renderer;
-    }
-    ngOnInit() {
-        this.subscriptions = (this.draggable.kendoPress.subscribe(this.start.bind(this)));
-        this.subscriptions.add(this.draggable.kendoDrag.subscribe(this.moveMarquee.bind(this)));
-    }
-    ngOnDestroy() {
-        this.subscriptions.unsubscribe();
-        this.clean();
-    }
-    start(args) {
-        const isInvalidTarget = args.originalEvent.target.matches('.k-grid-content, .k-grid-content-locked, .k-grid-aria-root, .k-checkbox');
-        const isRowReorderColumn = isPresent(args.originalEvent.target.closest('.k-drag-cell'));
-        if (isInvalidTarget || isRowReorderColumn) {
-            this.pressArgs = null;
-            return;
-        }
-        this.pressArgs = args;
-        this.pressTarget = null;
-    }
-    moveMarquee(args) {
-        if (!this.pressTarget) {
-            this.pressTarget = this.cellSelection.active ? this.cellSelection.mouseDownEventArgs : this.selection.mouseDownEventArgs;
-        }
-        const press = this.pressArgs;
-        if (!press) {
-            return;
-        }
-        if (!this.selectionStarted) {
-            const distance = Math.sqrt((args.pageX - press.pageX) ** 2 + (args.pageY - press.pageY) ** 2);
-            if (distance > MINIMAL_DRAG_DISTANCE) {
-                this.selectionStarted = true;
-                this.renderer.addClass(this.host.nativeElement, 'user-select-none');
-                this.renderer.setStyle(this.host.nativeElement, 'user-select', 'none');
-                this.dragEndSubscription = merge(this.domEvents.cellMouseup.pipe(take(1)), this.draggable.kendoRelease.pipe(delay(1), take(1)))
-                    .subscribe(this.endSelection.bind(this));
-            }
-            else {
-                return;
-            }
-        }
-        this.initMarquee();
-        const element = this.marqueeElement;
-        const marqueeQuadrant = this.getMarqueeQuadrant(args.pageX, args.pageY, press.pageX, press.pageY);
-        let left = Math.min(args.pageX, press.pageX);
-        let top = Math.min(args.pageY, press.pageY);
-        const width = Math.abs(args.pageX - press.pageX);
-        const height = Math.abs(args.pageY - press.pageY);
-        if (marqueeQuadrant) {
-            left += offsets[marqueeQuadrant].x;
-            top += offsets[marqueeQuadrant].y;
-        }
-        element.style.left = `${left}px`;
-        element.style.top = `${top}px`;
-        element.style.width = `${width}px`;
-        element.style.height = `${height}px`;
-    }
-    endSelection(args) {
-        if (args.type === 'mouseup' || args.type === 'touchend') {
-            const modifier = args.originalEvent.ctrlKey || args.originalEvent.metaKey;
-            const preserveCurrentSelection = modifier &&
-                (isMultipleRangesEnabled(this.selection.settings) ||
-                    isMultipleRangesEnabled(this.cellSelection.settings));
-            if (this.cellSelection.active) {
-                this.cellSelection.dragging = true;
-                this.cellSelection.changes.emit(this.cellSelection.selectRange(this.pressTarget.rowIndex, this.pressTarget.column.leafIndex, args.rowIndex, args.column.leafIndex, preserveCurrentSelection));
-            }
-            else if (this.selection.active) {
-                this.selection.dragging = true;
-                this.selection.changes.emit(this.selection.selectRange(this.pressTarget.rowIndex, args.rowIndex, preserveCurrentSelection));
-            }
-        }
-        this.clean();
-    }
-    clean() {
-        if (this.marqueeElement) {
-            document.body.removeChild(this.marqueeElement);
-            this.marqueeElement = null;
-        }
-        if (this.dragEndSubscription) {
-            this.dragEndSubscription.unsubscribe();
-        }
-        this.renderer.removeClass(this.host.nativeElement, 'user-select-none');
-        this.renderer.removeStyle(this.host.nativeElement, 'user-select');
-        this.dragEndSubscription = null;
-        this.pressTarget = null;
-        this.pressArgs = null;
-        this.selectionStarted = false;
-        // eslint-disable-next-line no-unused-expressions
-        this.cellSelection.active ? this.cellSelection.dragging = false : this.selection.dragging = false;
-    }
-    initMarquee() {
-        if (!isDocumentAvailable()) {
-            return;
-        }
-        if (!this.marqueeElement) {
-            this.marqueeElement = createElement();
-            document.body.appendChild(this.marqueeElement);
-        }
-    }
-    getMarqueeQuadrant(pointerX, pointerY, startX, startY) {
-        const leftHalf = pointerX < startX;
-        const rightHalf = pointerX > startX;
-        const topHalf = pointerY < startY;
-        const bottomHalf = pointerY > startY;
-        if (leftHalf && topHalf) {
-            return 'topLeft';
-        }
-        if (leftHalf && bottomHalf) {
-            return 'bottomLeft';
-        }
-        if (rightHalf && topHalf) {
-            return 'topRight';
-        }
-        if (rightHalf && bottomHalf) {
-            return 'bottomRight';
-        }
-        return null;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GridMarqueeDirective, deps: [{ token: i1.DraggableDirective }, { token: i2.SelectionService }, { token: i3.CellSelectionService }, { token: i4.DomEventsService }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: GridMarqueeDirective, isStandalone: true, selector: "[kendoGridSelectionMarquee]", ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GridMarqueeDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[kendoGridSelectionMarquee]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i1.DraggableDirective }, { type: i2.SelectionService }, { type: i3.CellSelectionService }, { type: i4.DomEventsService }, { type: i0.ElementRef }, { type: i0.Renderer2 }] });

package/esm2022/selection/pair-set.mjs

@@ -1,158 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * @hidden
- *
- * Quick look-up structure for combinations of keys or single keys.
- * Similar to the native JS Set, however, working with single keys or a couple of keys.
- * Supports both primitive keys and object keys (compared by reference).
- */
-export class PairSet {
-    /**
-     * Symbol used internally to represent "no Y key" when storing single X keys.
-     */
-    static SINGLE_KEY_SYMBOL = Symbol('SINGLE_KEY');
-    /**
-     * Gets the total number of key entries (both single keys and key pairs).
-     */
-    get size() {
-        return this.totalKeysCount;
-    }
-    /**
-     * Holds a set of Y keys for each defined X key.
-     * Each X key creates a map which holds a set of Y keys.
-     * For single keys, the Y value is the SINGLE_KEY_SYMBOL.
-     *
-     * Map { 'foo' => Set { Symbol(SINGLE_KEY) } } // single key: {x: 'foo'}
-     * Map { 'foo2' => Set { 'bar', 'baz' } } // pairs: {x: 'foo2', y: 'bar'}, {x: 'foo2', y: 'baz'}
-     */
-    keysX = new Map();
-    /**
-     * Count each added or deleted key manually to avoid iterating over all items when calling `this.size`.
-     */
-    totalKeysCount = 0;
-    constructor(items, keyXField, keyYField) {
-        if (items && keyXField) {
-            items.forEach(item => {
-                if (keyYField && item[keyYField] !== undefined) {
-                    this.add(item[keyXField], item[keyYField]);
-                }
-                else {
-                    this.addSingle(item[keyXField]);
-                }
-            });
-        }
-    }
-    /**
-     * Adds a single key entry.
-     */
-    addSingle(keyX) {
-        if (!this.keysX.has(keyX)) {
-            this.keysX.set(keyX, new Set());
-        }
-        if (!this.hasSingle(keyX)) {
-            this.keysX.get(keyX).add(PairSet.SINGLE_KEY_SYMBOL);
-            this.totalKeysCount += 1;
-        }
-    }
-    /**
-     * Adds a couple of items identified as a combination.
-     */
-    add(keyX, keyY) {
-        if (!this.keysX.has(keyX)) {
-            this.keysX.set(keyX, new Set());
-        }
-        if (!this.has(keyX, keyY)) {
-            this.keysX.get(keyX).add(keyY);
-            this.totalKeysCount += 1;
-        }
-    }
-    /**
-     * Deletes a single key entry.
-     */
-    deleteSingle(keyX) {
-        if (this.hasSingle(keyX)) {
-            this.keysX.get(keyX).delete(PairSet.SINGLE_KEY_SYMBOL);
-            this.totalKeysCount -= 1;
-            if (this.keysX.get(keyX).size === 0) {
-                this.keysX.delete(keyX);
-            }
-        }
-    }
-    /**
-     * Deletes a combination of a couple of items identified together.
-     */
-    delete(keyX, keyY) {
-        if (this.has(keyX, keyY)) {
-            this.keysX.get(keyX).delete(keyY);
-            this.totalKeysCount -= 1;
-            if (this.keysX.get(keyX).size === 0) {
-                this.keysX.delete(keyX);
-            }
-        }
-    }
-    /**
-     * Checks whether a single key is stored.
-     */
-    hasSingle(keyX) {
-        return this.keysX.has(keyX) && this.keysX.get(keyX).has(PairSet.SINGLE_KEY_SYMBOL);
-    }
-    /**
-     * Checks whether the defined combination is stored.
-     */
-    has(keyX, keyY) {
-        return this.keysX.has(keyX) && this.keysX.get(keyX).has(keyY);
-    }
-    /**
-     * Checks whether any entry exists for the given X key (single or paired).
-     */
-    hasX(keyX) {
-        return this.keysX.has(keyX) && this.keysX.get(keyX).size > 0;
-    }
-    /**
-     * Gets all Y keys for a given X key, excluding single key entries.
-     */
-    getYKeys(keyX) {
-        if (!this.keysX.has(keyX)) {
-            return [];
-        }
-        const yKeys = Array.from(this.keysX.get(keyX));
-        return yKeys.filter(yKey => yKey !== PairSet.SINGLE_KEY_SYMBOL);
-    }
-    /**
-     * Clears all key combinations and single keys.
-     */
-    clear() {
-        this.keysX.clear();
-        this.totalKeysCount = 0;
-    }
-    /**
-     * Converts the persisted data structure to an array of objects,
-     * using the provided field names for the object props.
-     * Single keys will only have the keyXField property.
-     * Pair keys will have both keyXField and keyYField properties.
-     */
-    toArray(keyXField, keyYField) {
-        return Array.from(this.keysX).reduce((pairs, pair) => {
-            // Array.from(mapInstance) returns an array of arrays [[itemKey1, columnKeysSet1], [itemKey2, columnKeysSet2]]
-            const [keyX, keysY] = pair;
-            Array.from(keysY).forEach(keyY => {
-                if (keyY === PairSet.SINGLE_KEY_SYMBOL) {
-                    // Single key entry
-                    pairs.push({ [keyXField]: keyX });
-                }
-                else {
-                    // Pair key entry
-                    const entry = { [keyXField]: keyX };
-                    if (keyYField) {
-                        entry[keyYField] = keyY;
-                    }
-                    pairs.push(entry);
-                }
-            });
-            return pairs;
-        }, []);
-    }
-}

package/esm2022/selection/selectall-checkbox.directive.mjs

@@ -1,143 +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, Input, Output, EventEmitter, NgZone, Host, Optional, Renderer2, ElementRef } from '@angular/core';
-import { SelectionService } from './selection.service';
-import { isPresent } from '../utils';
-import { hasObservers } from '@progress/kendo-angular-common';
-import { CellSelectionService } from './cell-selection.service';
-import { CheckBoxComponent } from '@progress/kendo-angular-inputs';
-import * as i0 from "@angular/core";
-import * as i1 from "./selection.service";
-import * as i2 from "./cell-selection.service";
-import * as i3 from "@progress/kendo-angular-inputs";
-/**
- * Adds a select-all checkbox to the Grid. [See example](slug:grid_selection_persistence#selecting-all-rows).
- *
- * @example
- * ```html
- * <kendo-checkbox
- *     kendoGridSelectAllCheckbox
- *     [state]="selectAllState"
- *     (selectAllChange)="onSelectAllChange($event)"
- * ></kendo-checkbox>
- * ```
- */
-export class SelectAllCheckboxDirective {
-    selectionService;
-    cellSelectionService;
-    ngZone;
-    element;
-    renderer;
-    checkbox;
-    /**
-     * Explicitly overrides the state of the select-all checkbox.
-     */
-    state;
-    /**
-     * Emits when the user clicks the select-all checkbox.
-     * ([see example](slug:grid_row_selection#toc-select-all-checkbox)).
-     */
-    selectAllChange = new EventEmitter();
-    destroyClick;
-    checkboxChange;
-    stateSet = false;
-    ngAfterContentChecked() {
-        this.setState();
-    }
-    ngOnChanges() {
-        this.stateSet = true;
-    }
-    constructor(selectionService, cellSelectionService, ngZone, element, renderer, checkbox) {
-        this.selectionService = selectionService;
-        this.cellSelectionService = cellSelectionService;
-        this.ngZone = ngZone;
-        this.element = element;
-        this.renderer = renderer;
-        this.checkbox = checkbox;
-        this.ngZone.runOutsideAngular(() => {
-            if (this.checkbox) {
-                this.checkboxChange = this.checkbox.checkedStateChange.subscribe(this.onClick.bind(this));
-            }
-            else {
-                this.destroyClick = this.renderer.listen(this.element.nativeElement, 'click', this.onClick.bind(this));
-            }
-        });
-    }
-    ngOnDestroy() {
-        if (this.checkboxChange) {
-            this.checkboxChange.unsubscribe();
-        }
-        if (this.destroyClick) {
-            this.destroyClick();
-        }
-    }
-    /**
-     * @hidden
-     */
-    onClick() {
-        const isIndeterminateState = this.checkbox?.checkedState === 'indeterminate' || this.element.nativeElement.indeterminate;
-        const isCheckedState = this.checkbox?.checkedState === true || this.element.nativeElement.checked;
-        const uncheckedState = isIndeterminateState ? 'indeterminate' : 'unchecked';
-        const checkboxState = isCheckedState ? 'checked' : uncheckedState;
-        const isChecked = this.selectionService.hasNonSelectable ? !this.selectionService.selectAllChecked : isCheckedState;
-        const options = this.selectionService.options;
-        const enabledAndMultiple = options.enabled && options.mode === 'multiple' && !this.cellSelectionService.active;
-        const shouldEmitSelectAll = hasObservers(this.selectAllChange);
-        if (enabledAndMultiple || shouldEmitSelectAll) {
-            this.ngZone.run(() => {
-                if (enabledAndMultiple) {
-                    this.selectionService.updateAll(isChecked);
-                }
-                if (shouldEmitSelectAll) {
-                    this.selectAllChange.emit(checkboxState);
-                }
-            });
-        }
-    }
-    /**
-     * @hidden
-     */
-    setState() {
-        const state = this.stateSet ? this.stateToBool() : this.selectionService.selectAllState;
-        if (this.checkbox) {
-            this.checkbox.checkedState = isPresent(state) ? state : 'indeterminate';
-        }
-        else {
-            const elem = this.element.nativeElement;
-            this.renderer.setProperty(elem, 'indeterminate', !isPresent(state));
-            this.renderer.setProperty(elem, 'checked', isPresent(state) ? state : false);
-        }
-    }
-    /**
-     * @hidden
-     */
-    stateToBool() {
-        switch (this.state) {
-            case 'checked':
-                return true;
-            case 'unchecked':
-                return false;
-            default:
-                return undefined;
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectAllCheckboxDirective, deps: [{ token: i1.SelectionService }, { token: i2.CellSelectionService }, { token: i0.NgZone }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i3.CheckBoxComponent, host: true, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: SelectAllCheckboxDirective, isStandalone: true, selector: "[kendoGridSelectAllCheckbox]", inputs: { state: "state" }, outputs: { selectAllChange: "selectAllChange" }, usesOnChanges: true, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectAllCheckboxDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[kendoGridSelectAllCheckbox]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i1.SelectionService }, { type: i2.CellSelectionService }, { type: i0.NgZone }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i3.CheckBoxComponent, decorators: [{
-                    type: Host
-                }, {
-                    type: Optional
-                }] }], propDecorators: { state: [{
-                type: Input
-            }], selectAllChange: [{
-                type: Output
-            }] } });

package/esm2022/selection/selection-checkbox.directive.mjs

@@ -1,132 +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, ElementRef, Input, Renderer2, NgZone, Host, Optional } from '@angular/core';
-import { SelectionService } from './selection.service';
-import { Keys } from '@progress/kendo-angular-common';
-import { CellSelectionAggregateService } from '../aggregates/selection-aggregate.service';
-import { CellSelectionService } from './cell-selection.service';
-import { CheckBoxComponent } from '@progress/kendo-angular-inputs';
-import * as i0 from "@angular/core";
-import * as i1 from "./selection.service";
-import * as i2 from "./cell-selection.service";
-import * as i3 from "../aggregates/selection-aggregate.service";
-import * as i4 from "@progress/kendo-angular-inputs";
-/**
- * Adds a row-selection checkbox to the Grid.
- * Use this directive on a `<kendo-checkbox>` component or `<input type="checkbox">` element inside a cell template.
- * When the user clicks the checkbox, the Grid triggers a [`selectionChange`](slug:api_grid_gridcomponent#toc-selectionChange) event.
- *
- * @example
- * ```html
- * <kendo-grid>
- *   <kendo-grid-column>
- *     <ng-template kendoGridCellTemplate let-rowIndex="rowIndex">
- *       <input [kendoGridSelectionCheckbox]="rowIndex"/>
- *       <kendo-checkbox [kendoGridSelectionCheckbox]="rowIndex"></kendo-checkbox>
- *     </ng-template>
- *   </kendo-grid-column>
- * </kendo-grid>
- * ```
- * @remarks
- * Applied to: {@link CheckBoxComponent}.
- */
-export class SelectionCheckboxDirective {
-    selectionService;
-    cellSelectionService;
-    aggregateService;
-    el;
-    renderer;
-    ngZone;
-    checkbox;
-    /**
-     * Sets the index of the `dataItem` to select.
-     */
-    itemIndex;
-    destroyClick;
-    destroyKeyDown;
-    ngAfterContentChecked() {
-        this.setCheckedState();
-    }
-    constructor(selectionService, cellSelectionService, aggregateService, el, renderer, ngZone, checkbox) {
-        this.selectionService = selectionService;
-        this.cellSelectionService = cellSelectionService;
-        this.aggregateService = aggregateService;
-        this.el = el;
-        this.renderer = renderer;
-        this.ngZone = ngZone;
-        this.checkbox = checkbox;
-        this.ngZone.runOutsideAngular(() => {
-            this.destroyClick = this.renderer.listen(this.el.nativeElement, 'click', this.onClick.bind(this));
-            this.destroyKeyDown = this.renderer.listen(this.el.nativeElement, 'keydown', this.onKeyDown.bind(this));
-        });
-    }
-    ngOnDestroy() {
-        if (this.destroyClick) {
-            this.destroyClick();
-        }
-        if (this.destroyKeyDown) {
-            this.destroyKeyDown();
-        }
-    }
-    onClick(event) {
-        const nonSelectableRow = this.selectionService.nonSelectableRows.has(this.itemIndex) || this.cellSelectionService.nonSelectableRows.has(this.itemIndex);
-        if (nonSelectableRow || this.cellSelectionService.active) {
-            event.preventDefault();
-            return;
-        }
-        if (this.selectionService.options.enabled) {
-            this.ngZone.run(() => {
-                let ev;
-                const ctrlKey = event.ctrlKey || event.metaKey;
-                if (event.shiftKey && this.selectionService.options.mode === 'multiple') {
-                    const item = { index: this.itemIndex };
-                    ev = this.selectionService.addAllTo(item, ctrlKey, false, event.shiftKey);
-                }
-                else {
-                    ev = this.selectionService.toggleByIndex(this.itemIndex);
-                }
-                ev.ctrlKey = event.ctrlKey;
-                ev.shiftKey = event.shiftKey;
-                if (this.selectionService.options.cellAggregates) {
-                    ev.cellAggregates = this.aggregateService.onSelectionChange(ev);
-                }
-                this.selectionService.changes.emit(ev);
-            });
-        }
-    }
-    onKeyDown(e) {
-        if (e.code === Keys.Enter || e.code === Keys.NumpadEnter) {
-            this.onClick(e);
-        }
-    }
-    /*
-     * @hidden
-     */
-    setCheckedState() {
-        const isSelected = this.selectionService.nonSelectableRows.has(this.itemIndex) ? false : this.selectionService.isSelected(this.itemIndex);
-        if (this.checkbox) {
-            this.checkbox.checkedState = isSelected;
-        }
-        else {
-            this.renderer.setProperty(this.el.nativeElement, 'checked', isSelected);
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectionCheckboxDirective, deps: [{ token: i1.SelectionService }, { token: i2.CellSelectionService }, { token: i3.CellSelectionAggregateService }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: i4.CheckBoxComponent, host: true, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: SelectionCheckboxDirective, isStandalone: true, selector: "[kendoGridSelectionCheckbox]", inputs: { itemIndex: ["kendoGridSelectionCheckbox", "itemIndex"] }, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectionCheckboxDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[kendoGridSelectionCheckbox]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i1.SelectionService }, { type: i2.CellSelectionService }, { type: i3.CellSelectionAggregateService }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: i4.CheckBoxComponent, decorators: [{
-                    type: Host
-                }, {
-                    type: Optional
-                }] }], propDecorators: { itemIndex: [{
-                type: Input,
-                args: ['kendoGridSelectionCheckbox']
-            }] } });