@progress/kendo-angular-grid 7.0.0-dev.202201251337 → 7.0.0-dev.202204191045

package/esm2015/filtering/filter-host.directive.js

@@ -0,0 +1,54 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Input, Directive } from '@angular/core';
+import { anyChanged } from '../utils';
+import * as i0 from "@angular/core";
+/**
+ * @hidden
+ */
+export class FilterHostDirective {
+    constructor(host, resolver) {
+        this.host = host;
+        this.resolver = resolver;
+    }
+    ngOnInit() {
+        this.component = this.host.createComponent(this.resolver.resolveComponentFactory(this.componentType()));
+        this.initComponent({
+            column: this.column,
+            filter: this.filter
+        });
+    }
+    ngOnDestroy() {
+        if (this.component) {
+            this.component.destroy();
+            this.component = null;
+        }
+    }
+    ngOnChanges(changes) {
+        if (anyChanged(["column", "filter"], changes)) {
+            this.initComponent({
+                column: this.column,
+                filter: this.filter
+            });
+        }
+    }
+    initComponent({ column, filter }) {
+        const instance = this.component.instance;
+        instance.column = column;
+        instance.filter = filter;
+    }
+}
+FilterHostDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FilterHostDirective, deps: [{ token: i0.ViewContainerRef }, { token: i0.ComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.Directive });
+FilterHostDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: FilterHostDirective, selector: "[kendoGridFilterHostBase]", inputs: { column: "column", filter: "filter" }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FilterHostDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoGridFilterHostBase]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.ComponentFactoryResolver }]; }, propDecorators: { column: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }] } });

package/esm2015/filtering/filter-input-wrapper.component.js

@@ -0,0 +1,117 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Input, ContentChild, Component } from "@angular/core";
+import { FilterInputDirective } from "./filter-input.directive";
+import { isPresent, isNullOrEmptyString, isBlank, isChanged } from "../utils";
+import { BaseFilterCellComponent } from "./base-filter-cell.component";
+import * as i0 from "@angular/core";
+import * as i1 from "./filter.service";
+const EMPTY_VALUE_OPERATORS = new Set(['isnull', 'isnotnull', 'isempty', 'isnotempty']);
+const isEmptyValueOperator = (operator) => EMPTY_VALUE_OPERATORS.has(operator);
+/**
+ * @hidden
+ */
+export class FilterInputWrapperComponent extends BaseFilterCellComponent {
+    constructor(filterService) {
+        super(filterService);
+    }
+    get currentFilter() {
+        return this.filterByField(this.column.field);
+    }
+    get currentOperator() {
+        const filter = this.currentFilter;
+        if (!this._operator) {
+            this._operator = filter ? filter.operator : this.defaultOperator;
+        }
+        return this._operator;
+    }
+    set currentOperator(value) {
+        this._operator = value;
+        const emptyValueOperator = isEmptyValueOperator(value);
+        this.filterInputDisabled = emptyValueOperator;
+        if (emptyValueOperator) {
+            this.applyNoValueFilter(value);
+        }
+        else if (!isBlank(value) && isPresent(this.currentFilter)) {
+            this.onChange(this.currentFilter.value);
+        }
+    }
+    get defaultOperator() {
+        if (!isNullOrEmptyString(this._defaultOperator)) {
+            return this._defaultOperator;
+        }
+        else if (this.operators && this.operators.length) {
+            return this.operators[0].value;
+        }
+        return "eq";
+    }
+    set defaultOperator(value) {
+        this._defaultOperator = value;
+    }
+    set filterInputDisabled(disabled) {
+        if (!this.input) {
+            return;
+        }
+        this.input.disabled = disabled;
+    }
+    ngAfterContentInit() {
+        if (isPresent(this.input)) {
+            this.changeSubscription = this.input.change.subscribe(this.onChange.bind(this));
+            this.filterInputDisabled = isEmptyValueOperator(this.currentOperator);
+        }
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        if (this.changeSubscription) {
+            this.changeSubscription.unsubscribe();
+        }
+    }
+    onChange(value) {
+        if (!isNullOrEmptyString(value) || this.filterByField(this.column.field)) {
+            this.filterChange(isNullOrEmptyString(value) ?
+                this.removeFilter(this.column.field) :
+                this.updateFilter({
+                    field: this.column.field,
+                    operator: this.currentOperator,
+                    value: value
+                }));
+        }
+    }
+    onClear() {
+        this.onChange(null);
+        this.filterInputDisabled = isEmptyValueOperator(this.defaultOperator);
+    }
+    applyNoValueFilter(operator) {
+        this.filterChange(this.updateFilter({
+            field: this.column.field,
+            operator: operator,
+            value: null
+        }));
+    }
+    ngOnChanges(changes) {
+        if (isChanged("filter", changes, false)) {
+            this._operator = null;
+            this.filterInputDisabled = isEmptyValueOperator(this.currentOperator);
+        }
+    }
+}
+FilterInputWrapperComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FilterInputWrapperComponent, deps: [{ token: i1.FilterService }], target: i0.ɵɵFactoryTarget.Component });
+FilterInputWrapperComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: FilterInputWrapperComponent, selector: "kendo-grid-filter-input-wrapper-base", inputs: { column: "column", filter: "filter", defaultOperator: "defaultOperator" }, queries: [{ propertyName: "input", first: true, predicate: FilterInputDirective, descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: ``, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FilterInputWrapperComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'kendo-grid-filter-input-wrapper-base',
+                    template: ``
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FilterService }]; }, propDecorators: { column: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], input: [{
+                type: ContentChild,
+                args: [FilterInputDirective, { static: false }]
+            }], defaultOperator: [{
+                type: Input
+            }] } });

package/esm2015/filtering/filter-input.directive.js

@@ -0,0 +1,99 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive, EventEmitter, Inject, Input, Self, ContentChild } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { debounceTime, filter } from 'rxjs/operators';
+import { Subject } from 'rxjs';
+import { isChanged } from '../utils';
+import { isDocumentAvailable, KendoInput } from '@progress/kendo-angular-common';
+import * as i0 from "@angular/core";
+/**
+ * @hidden
+ */
+export class FilterInputDirective {
+    constructor(valueAccessors, ngZone, element, renderer) {
+        this.element = element;
+        this.renderer = renderer;
+        this.change = new EventEmitter();
+        this.composing = false;
+        this.filterDelay = 500;
+        this.changeRequests = new Subject();
+        this.accessor = valueAccessors[0];
+        ngZone.runOutsideAngular(() => {
+            const unsubscribeStart = renderer.listen(element.nativeElement, 'compositionstart', () => this.composing = true);
+            const unsubscribeEnd = renderer.listen(element.nativeElement, 'compositionend', () => this.composing = false);
+            this.unsubscribeEvents = () => {
+                unsubscribeStart();
+                unsubscribeEnd();
+            };
+        });
+    }
+    set value(value) {
+        this.accessor.writeValue(value);
+    }
+    set disabled(value) {
+        this.accessor.setDisabledState(value);
+    }
+    ngAfterViewInit() {
+        this.addAriaAttributes();
+        this.accessor.registerOnChange(x => this.filterDelay > 0 ?
+            this.changeRequests.next(x) :
+            this.change.emit(x));
+        this.subscribeChanges();
+    }
+    ngOnChanges(changes) {
+        if (isChanged('filterDelay', changes)) {
+            this.unsubscribeChanges();
+            this.subscribeChanges();
+        }
+    }
+    ngOnDestroy() {
+        this.unsubscribeChanges();
+        this.unsubscribeEvents();
+    }
+    subscribeChanges() {
+        this.changeRequestsSubscription = this.changeRequests
+            .pipe(debounceTime(this.filterDelay), filter(() => !this.composing))
+            .subscribe(x => this.change.emit(x));
+    }
+    unsubscribeChanges() {
+        if (this.changeRequestsSubscription) {
+            this.changeRequestsSubscription.unsubscribe();
+        }
+    }
+    addAriaAttributes() {
+        const ariaValue = this.columnLabel;
+        if (this.kendoInput && this.kendoInput.focusableId && isDocumentAvailable()) {
+            const focusableElement = this.element.nativeElement.querySelector(`#${this.kendoInput.focusableId}`) ||
+                this.element.nativeElement;
+            this.renderer.setAttribute(focusableElement, 'aria-label', ariaValue);
+        }
+        else {
+            this.renderer.setAttribute(this.element.nativeElement, 'aria-label', ariaValue);
+        }
+    }
+}
+FilterInputDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FilterInputDirective, deps: [{ token: NG_VALUE_ACCESSOR, self: true }, { token: i0.NgZone }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+FilterInputDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: FilterInputDirective, selector: "[kendoFilterInput]", inputs: { filterDelay: "filterDelay", columnLabel: "columnLabel", value: "value" }, queries: [{ propertyName: "kendoInput", first: true, predicate: KendoInput, descendants: true, static: true }], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FilterInputDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoFilterInput]'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Self
+                }, {
+                    type: Inject,
+                    args: [NG_VALUE_ACCESSOR]
+                }] }, { type: i0.NgZone }, { type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { kendoInput: [{
+                type: ContentChild,
+                args: [KendoInput, { static: true }]
+            }], filterDelay: [{
+                type: Input
+            }], columnLabel: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }] } });

package/esm2015/filtering/filter-row.component.js

@@ -0,0 +1,103 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, Input, HostBinding } from '@angular/core';
+import { replaceMessagePlaceholder } from '../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-l10n";
+import * as i2 from "./../common/column-info.service";
+import * as i3 from "./cell/filter-cell.component";
+import * as i4 from "@angular/common";
+import * as i5 from "../navigation/logical-cell.directive";
+/**
+ * @hidden
+ */
+export class FilterRowComponent {
+    constructor(localization, columnInfoService) {
+        this.localization = localization;
+        this.columnInfoService = columnInfoService;
+        this.columns = [];
+        this.groups = [];
+        this.filterRowClass = true;
+    }
+    addStickyStyles(column) {
+        const sticky = column.sticky ? this.columnInfoService.stickyColumnsStyles(column) : null;
+        return Object.assign(Object.assign({}, sticky), column.filterStyle);
+    }
+    filterLabel(column) {
+        const localizationMsg = this.localization.get('filterInputLabel') || '';
+        const columnName = column.title || column.field;
+        return replaceMessagePlaceholder(localizationMsg, 'columnName', columnName);
+    }
+}
+FilterRowComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FilterRowComponent, deps: [{ token: i1.LocalizationService }, { token: i2.ColumnInfoService }], target: i0.ɵɵFactoryTarget.Component });
+FilterRowComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: FilterRowComponent, selector: "[kendoGridFilterRow]", inputs: { columns: "columns", filter: "filter", groups: "groups", detailTemplate: "detailTemplate", logicalRowIndex: "logicalRowIndex", lockedColumnsCount: "lockedColumnsCount" }, host: { properties: { "class.k-filter-row": "this.filterRowClass" } }, ngImport: i0, template: `
+        <td
+            [class.k-group-cell]="true"
+            *ngFor="let g of groups"
+            role="presentation">
+        </td>
+        <td
+            [class.k-hierarchy-cell]="true"
+            *ngIf="detailTemplate?.templateRef"
+            role="presentation">
+        </td>
+        <td *ngFor="let column of columns; let columnIndex = index"
+            [class.k-grid-header-sticky]="column.sticky"
+            [ngStyle]="addStickyStyles(column)"
+            [ngClass]="column.filterClass"
+            [attr.aria-label]="filterLabel($any(column))"
+            kendoGridFilterCell
+                [column]="$any(column)"
+                [filter]="filter"
+            kendoGridLogicalCell
+                [logicalRowIndex]="logicalRowIndex"
+                [logicalColIndex]="lockedColumnsCount + columnIndex"
+      ></td>
+    `, isInline: true, components: [{ type: i3.FilterCellComponent, selector: "[kendoGridFilterCell]", inputs: ["column", "filter"] }], directives: [{ type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.LogicalCellDirective, selector: "[kendoGridLogicalCell]", inputs: ["logicalColIndex", "logicalRowIndex", "logicalSlaveCell", "colIndex", "colSpan", "rowSpan", "groupItem", "dataRowIndex", "dataItem", "detailExpandCell", "headerLabelText"] }, { type: i4.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FilterRowComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: '[kendoGridFilterRow]',
+                    template: `
+        <td
+            [class.k-group-cell]="true"
+            *ngFor="let g of groups"
+            role="presentation">
+        </td>
+        <td
+            [class.k-hierarchy-cell]="true"
+            *ngIf="detailTemplate?.templateRef"
+            role="presentation">
+        </td>
+        <td *ngFor="let column of columns; let columnIndex = index"
+            [class.k-grid-header-sticky]="column.sticky"
+            [ngStyle]="addStickyStyles(column)"
+            [ngClass]="column.filterClass"
+            [attr.aria-label]="filterLabel($any(column))"
+            kendoGridFilterCell
+                [column]="$any(column)"
+                [filter]="filter"
+            kendoGridLogicalCell
+                [logicalRowIndex]="logicalRowIndex"
+                [logicalColIndex]="lockedColumnsCount + columnIndex"
+      ></td>
+    `
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }, { type: i2.ColumnInfoService }]; }, propDecorators: { columns: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], groups: [{
+                type: Input
+            }], detailTemplate: [{
+                type: Input
+            }], logicalRowIndex: [{
+                type: Input
+            }], lockedColumnsCount: [{
+                type: Input
+            }], filterRowClass: [{
+                type: HostBinding,
+                args: ['class.k-filter-row']
+            }] } });

package/esm2015/filtering/filter.service.js

@@ -0,0 +1,39 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable, Optional } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./menu/menu-tabbing.service";
+/**
+ * Represents a service to set the filter descriptor
+ * ([see example]({% slug reusablecustomfilters_grid %})).
+ */
+export class FilterService {
+    /**
+     * @hidden
+     */
+    constructor(menuTabbingService) {
+        /**
+         * Fires when the filter descriptors is set.
+         */
+        this.changes = new Subject();
+        this.menuTabbingService = menuTabbingService;
+    }
+    /**
+     * Sets the filter descriptor.
+     *
+     * @param {CompositeFilterDescriptor} value - The filter descriptor that will be set.
+     */
+    filter(value) {
+        this.changes.next(value);
+    }
+}
+FilterService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FilterService, deps: [{ token: i1.MenuTabbingService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+FilterService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FilterService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FilterService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.MenuTabbingService, decorators: [{
+                    type: Optional
+                }] }]; } });

package/esm2015/filtering/menu/boolean-filter-menu.component.js

@@ -0,0 +1,147 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, Input, HostBinding, ViewChildren } from '@angular/core';
+import { BooleanFilterComponent } from '../boolean-filter.component';
+import { guid } from '@progress/kendo-angular-common';
+import { BooleanFilterRadioButtonDirective } from './filter-radio-button.directive';
+import { replaceMessagePlaceholder } from '../../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-l10n";
+import * as i2 from "@angular/common";
+import * as i3 from "@progress/kendo-angular-inputs";
+import * as i4 from "./filter-radio-button.directive";
+/**
+ * Represents a Boolean-filter menu component.
+ *
+ * @example
+ *  ```html-no-run
+ *      <kendo-grid-column field="Discontinued" title="Discontinued">
+ *          <ng-template kendoGridFilterMenuTemplate let-filter let-column="column" let-filterService="filterService">
+ *            <kendo-grid-boolean-filter-menu
+ *                [column]="column"
+ *                [filter]="filter"
+ *                [filterService]="filterService"
+ *                >
+ *            </kendo-grid-boolean-filter-menu>
+ *          </ng-template>
+ *      </kendo-grid-column>
+ *   ```
+ */
+export class BooleanFilterMenuComponent extends BooleanFilterComponent {
+    constructor(localization) {
+        super(null, localization);
+        /**
+         * The current menu filter.
+         * @type {CompositeFilterDescriptor}
+         */
+        this.filter = { filters: [], logic: "and" };
+        this.idPrefix = guid();
+    }
+    /**
+     * @hidden
+     */
+    get hostClasses() {
+        return false;
+    }
+    ngAfterViewInit() {
+        this.filterService.menuTabbingService.firstFocusable = this.radioButtons.first.radioButtonEl;
+        this.radioButtons.first.radioButtonEl.focus();
+    }
+    /**
+     * @hidden
+     */
+    radioId(value) {
+        return `${this.idPrefix}_${value}`;
+    }
+    /**
+     * @hidden
+     */
+    onChange(value, input) {
+        this.applyFilter(this.updateFilter({
+            field: this.column.field,
+            operator: "eq",
+            value: value
+        }));
+        this.filterService.menuTabbingService.firstFocusable = input;
+    }
+    /**
+     * @hidden
+     */
+    isSelected(radioValue) {
+        return this.filtersByField(this.column.field).some(({ value }) => value === radioValue);
+    }
+    /**
+     * @hidden
+     */
+    onShiftTab(e) {
+        if ((!this.menuTabbingService || !this.menuTabbingService.isColumnMenu) && this.filterService.menuTabbingService.lastFocusable) {
+            e.preventDefault();
+            this.filterService.menuTabbingService.lastFocusable.focus();
+        }
+    }
+    /**
+     * @hidden
+     */
+    get columnLabel() {
+        const localizationMsg = this.localization.get('filterInputLabel') || '';
+        const columnName = this.column.title || this.column.field;
+        return replaceMessagePlaceholder(localizationMsg, 'columnName', columnName);
+    }
+}
+BooleanFilterMenuComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: BooleanFilterMenuComponent, deps: [{ token: i1.LocalizationService }], target: i0.ɵɵFactoryTarget.Component });
+BooleanFilterMenuComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: BooleanFilterMenuComponent, selector: "kendo-grid-boolean-filter-menu", inputs: { filter: "filter", filterService: "filterService", menuTabbingService: "menuTabbingService" }, host: { properties: { "class.k-filtercell": "this.hostClasses" } }, viewQueries: [{ propertyName: "radioButtons", predicate: BooleanFilterRadioButtonDirective, descendants: true }], usesInheritance: true, ngImport: i0, template: `
+        <ul class="k-radio-list k-reset">
+            <li *ngFor="let item of items">
+                <input type="radio"
+                    kendoFilterMenuRadioButton
+                    [columnLabel]="columnLabel"
+                    #input
+                    [name]="idPrefix"
+                    kendoRadioButton
+                    [checked]="isSelected(item.value)"
+                    [attr.id]="radioId(item.value)"
+                    (change)="onChange(item.value, input)"
+                    (keydown.shift.tab)="onShiftTab($event)"
+                />
+                <label class="k-radio-label" [attr.for]="radioId(item.value)">{{item.text}}</label>
+            </li>
+        </ul>
+    `, isInline: true, directives: [{ type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3.RadioButtonDirective, selector: "input[kendoRadioButton]", inputs: ["size"] }, { type: i4.BooleanFilterRadioButtonDirective, selector: "[kendoFilterMenuRadioButton]", inputs: ["columnLabel"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: BooleanFilterMenuComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'kendo-grid-boolean-filter-menu',
+                    template: `
+        <ul class="k-radio-list k-reset">
+            <li *ngFor="let item of items">
+                <input type="radio"
+                    kendoFilterMenuRadioButton
+                    [columnLabel]="columnLabel"
+                    #input
+                    [name]="idPrefix"
+                    kendoRadioButton
+                    [checked]="isSelected(item.value)"
+                    [attr.id]="radioId(item.value)"
+                    (change)="onChange(item.value, input)"
+                    (keydown.shift.tab)="onShiftTab($event)"
+                />
+                <label class="k-radio-label" [attr.for]="radioId(item.value)">{{item.text}}</label>
+            </li>
+        </ul>
+    `
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }]; }, propDecorators: { hostClasses: [{
+                type: HostBinding,
+                args: ['class.k-filtercell']
+            }], filter: [{
+                type: Input
+            }], filterService: [{
+                type: Input
+            }], menuTabbingService: [{
+                type: Input
+            }], radioButtons: [{
+                type: ViewChildren,
+                args: [BooleanFilterRadioButtonDirective]
+            }] } });