@progress/kendo-angular-grid
Version:
Kendo UI Grid for Angular - high performance data grid with paging, filtering, virtualization, CRUD, and more.
175 lines (174 loc) • 5.9 kB
JavaScript
/**-----------------------------------------------------------------------------------------
* Copyright © 2025 Progress Software Corporation. All rights reserved.
* Licensed under commercial license. See LICENSE.md in the project root for more information
*-------------------------------------------------------------------------------------------*/
import { ContentChildren, QueryList, HostBinding, Directive } from '@angular/core';
import { FilterService } from './filter.service';
import { isCompositeFilterDescriptor } from '@progress/kendo-data-query';
import { isPresent, observe } from '../utils';
import { FilterOperatorBase, toJSON } from './operators/filter-operator.base';
import { map } from 'rxjs/operators';
import { Input } from '@angular/core';
import * as i0 from "@angular/core";
import * as i1 from "./filter.service";
const insertDefaultFilter = (index, rootFilter, filter) => {
rootFilter = (rootFilter || { filters: [], logic: "and" });
rootFilter.filters[index] = filter;
return filter;
};
/**
* @hidden
*/
export const setFilter = (index, filter, field, defaultOperator) => {
if (isPresent(filter) && isPresent(filter.filters) && filter.filters.length > index) {
return filter.filters[index];
}
else {
return insertDefaultFilter(index, filter, {
field,
operator: defaultOperator
});
}
};
/**
* @hidden
*/
export const logicOperators = (localization) => [
{ text: localization.get("filterAndLogic"), value: "and" },
{ text: localization.get("filterOrLogic"), value: "or" }
];
/**
* @hidden
*/
export const flatten = (filter) => {
if (isPresent(filter.filters)) {
return filter.filters.reduce((acc, curr) => acc.concat(isCompositeFilterDescriptor(curr) ? flatten(curr) : [curr]), []);
}
return [];
};
const trimFilterByField = (filter, field) => {
if (isPresent(filter) && isPresent(filter.filters)) {
filter.filters = filter.filters.filter(x => {
if (isCompositeFilterDescriptor(x)) {
trimFilterByField(x, field);
return x.filters.length;
}
else {
return x.field !== field;
}
});
}
};
/**
* @hidden
*/
export const filtersByField = (filter, field) => flatten(filter || {}).filter(x => x.field === field);
/**
* @hidden
*/
export const filterByField = (filter, field) => {
const [currentFilter] = filtersByField(filter, field);
return currentFilter;
};
/**
* @hidden
*/
export const removeFilter = (filter, field) => {
trimFilterByField(filter, field);
return filter;
};
/**
* @hidden
*/
export const localizeOperators = operators => localization => Object.keys(operators).map(key => ({
text: localization.get(key),
value: operators[key]
}));
/**
* An abstract base class for the filter-cell component ([see example]({% slug filter_row %}#toc-custom-filter-row-components)).
*/
export class BaseFilterCellComponent {
filterService;
get hostClasses() {
return true;
}
operatorList = new QueryList();
get operators() {
return this._operators?.length ? this._operators : this.defaultOperators;
}
set operators(values) {
this._operators = values;
}
/**
* @hidden
*/
size = 'medium';
/**
* The current root filter.
* @type {CompositeFilterDescriptor}
*/
filter;
defaultOperators;
_operators;
operationListSubscription;
constructor(filterService) {
this.filterService = filterService;
}
/**
* @hidden
*/
ngAfterContentInit() {
this.operationListSubscription = observe(this.operatorList)
.pipe(map(q => q.toArray()), map(toJSON))
.subscribe(x => {
this.operators = x;
});
}
ngOnDestroy() {
if (this.operationListSubscription) {
this.operationListSubscription.unsubscribe();
}
}
filterByField(field) {
return filterByField(this.filter, field);
}
filtersByField(field) {
return filtersByField(this.filter, field);
}
removeFilter(field) {
return removeFilter(this.filter, field);
}
updateFilter(filter) {
const root = this.filter || {
filters: [],
logic: "and"
};
const [currentFilter] = flatten(root).filter(x => x.field === filter.field);
if (!isPresent(currentFilter)) {
root.filters.push(filter);
}
else {
Object.assign(currentFilter, filter);
}
return root;
}
applyFilter(filter) {
this.filterService.filter(filter);
}
static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BaseFilterCellComponent, deps: [{ token: i1.FilterService }], target: i0.ɵɵFactoryTarget.Directive });
static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: BaseFilterCellComponent, inputs: { operators: "operators", filter: "filter" }, host: { properties: { "class.k-filtercell": "this.hostClasses" } }, queries: [{ propertyName: "operatorList", predicate: FilterOperatorBase }], ngImport: i0 });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BaseFilterCellComponent, decorators: [{
type: Directive,
args: [{}]
}], ctorParameters: function () { return [{ type: i1.FilterService }]; }, propDecorators: { hostClasses: [{
type: HostBinding,
args: ['class.k-filtercell']
}], operatorList: [{
type: ContentChildren,
args: [FilterOperatorBase]
}], operators: [{
type: Input
}], filter: [{
type: Input
}] } });