@progress/kendo-angular-treelist 4.0.6 → 5.0.0-next.202204131014

package/esm2015/filtering/operators/is-not-empty-filter-operator.component.js

@@ -0,0 +1,38 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-l10n";
+/**
+ * Represents the `IsNotEmpty` (**Is not empty**) filter operator.
+ *
+ * For more information and examples, refer to:
+ * * [Setting the default filter operators]({% slug builtinfiltertemplate_treelist %}#toc-setting-the-default-filter-operator)
+ * * [Setting the order of the filter operators]({% slug builtinfiltertemplate_treelist %}#toc-setting-the-order-of-the-filter-operators)
+ */
+export class IsNotEmptyFilterOperatorComponent extends FilterOperatorBase {
+    constructor(localization) { super("isnotempty", localization); }
+}
+IsNotEmptyFilterOperatorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: IsNotEmptyFilterOperatorComponent, deps: [{ token: i1.LocalizationService }], target: i0.ɵɵFactoryTarget.Component });
+IsNotEmptyFilterOperatorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: IsNotEmptyFilterOperatorComponent, selector: "kendo-treelist-filter-isnotempty-operator", providers: [
+        {
+            provide: FilterOperatorBase,
+            useExisting: forwardRef(() => IsNotEmptyFilterOperatorComponent)
+        }
+    ], usesInheritance: true, ngImport: i0, template: ``, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: IsNotEmptyFilterOperatorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    providers: [
+                        {
+                            provide: FilterOperatorBase,
+                            useExisting: forwardRef(() => IsNotEmptyFilterOperatorComponent)
+                        }
+                    ],
+                    selector: 'kendo-treelist-filter-isnotempty-operator',
+                    template: ``
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }]; } });

package/esm2015/filtering/operators/is-not-null-filter-operator.component.js

@@ -0,0 +1,38 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-l10n";
+/**
+ * Represents the `IsNotNull` (**Is not null**) filter operator.
+ *
+ * For more information and examples, refer to:
+ * * [Setting the default filter operators]({% slug builtinfiltertemplate_treelist %}#toc-setting-the-default-filter-operator)
+ * * [Setting the order of the filter operators]({% slug builtinfiltertemplate_treelist %}#toc-setting-the-order-of-the-filter-operators)
+ */
+export class IsNotNullFilterOperatorComponent extends FilterOperatorBase {
+    constructor(localization) { super("isnotnull", localization); }
+}
+IsNotNullFilterOperatorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: IsNotNullFilterOperatorComponent, deps: [{ token: i1.LocalizationService }], target: i0.ɵɵFactoryTarget.Component });
+IsNotNullFilterOperatorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: IsNotNullFilterOperatorComponent, selector: "kendo-treelist-filter-isnotnull-operator", providers: [
+        {
+            provide: FilterOperatorBase,
+            useExisting: forwardRef(() => IsNotNullFilterOperatorComponent)
+        }
+    ], usesInheritance: true, ngImport: i0, template: ``, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: IsNotNullFilterOperatorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    providers: [
+                        {
+                            provide: FilterOperatorBase,
+                            useExisting: forwardRef(() => IsNotNullFilterOperatorComponent)
+                        }
+                    ],
+                    selector: 'kendo-treelist-filter-isnotnull-operator',
+                    template: ``
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }]; } });

package/esm2015/filtering/operators/isnull-filter-operator.component.js

@@ -0,0 +1,38 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-l10n";
+/**
+ * Represents the `IsNull` (**Is null**) filter operator.
+ *
+ * For more information and examples, refer to:
+ * * [Setting the default filter operators]({% slug builtinfiltertemplate_treelist %}#toc-setting-the-default-filter-operator)
+ * * [Setting the order of the filter operators]({% slug builtinfiltertemplate_treelist %}#toc-setting-the-order-of-the-filter-operators)
+ */
+export class IsNullFilterOperatorComponent extends FilterOperatorBase {
+    constructor(localization) { super("isnull", localization); }
+}
+IsNullFilterOperatorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: IsNullFilterOperatorComponent, deps: [{ token: i1.LocalizationService }], target: i0.ɵɵFactoryTarget.Component });
+IsNullFilterOperatorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: IsNullFilterOperatorComponent, selector: "kendo-treelist-filter-isnull-operator", providers: [
+        {
+            provide: FilterOperatorBase,
+            useExisting: forwardRef(() => IsNullFilterOperatorComponent)
+        }
+    ], usesInheritance: true, ngImport: i0, template: ``, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: IsNullFilterOperatorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    providers: [
+                        {
+                            provide: FilterOperatorBase,
+                            useExisting: forwardRef(() => IsNullFilterOperatorComponent)
+                        }
+                    ],
+                    selector: 'kendo-treelist-filter-isnull-operator',
+                    template: ``
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }]; } });

package/esm2015/filtering/operators/lt-filter-operator.component.js

@@ -0,0 +1,38 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-l10n";
+/*
+ * Represents the `Less` (**Is less than**) numeric filter operator.
+ *
+ * For more information and examples, refer to:
+ * * [Setting the default filter operators]({% slug builtinfiltertemplate_treelist %}#toc-setting-the-default-filter-operator)
+ * * [Setting the order of the filter operators]({% slug builtinfiltertemplate_treelist %}#toc-setting-the-order-of-the-filter-operators)
+ */
+export class LessFilterOperatorComponent extends FilterOperatorBase {
+    constructor(localization) { super("lt", localization); }
+}
+LessFilterOperatorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: LessFilterOperatorComponent, deps: [{ token: i1.LocalizationService }], target: i0.ɵɵFactoryTarget.Component });
+LessFilterOperatorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: LessFilterOperatorComponent, selector: "kendo-treelist-filter-lt-operator", providers: [
+        {
+            provide: FilterOperatorBase,
+            useExisting: forwardRef(() => LessFilterOperatorComponent)
+        }
+    ], usesInheritance: true, ngImport: i0, template: ``, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: LessFilterOperatorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    providers: [
+                        {
+                            provide: FilterOperatorBase,
+                            useExisting: forwardRef(() => LessFilterOperatorComponent)
+                        }
+                    ],
+                    selector: 'kendo-treelist-filter-lt-operator',
+                    template: ``
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }]; } });

package/esm2015/filtering/operators/lte-filter-operator.component.js

@@ -0,0 +1,38 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-l10n";
+/*
+ * Represents the `LessOrEqualTo` (**Is less than or equal to**) numeric filter operator.
+ *
+ * For more information and examples, refer to:
+ * * [Setting the default filter operators]({% slug builtinfiltertemplate_treelist %}#toc-setting-the-default-filter-operator)
+ * * [Setting the order of the filter operators]({% slug builtinfiltertemplate_treelist %}#toc-setting-the-order-of-the-filter-operators)
+ */
+export class LessOrEqualToFilterOperatorComponent extends FilterOperatorBase {
+    constructor(localization) { super("lte", localization); }
+}
+LessOrEqualToFilterOperatorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: LessOrEqualToFilterOperatorComponent, deps: [{ token: i1.LocalizationService }], target: i0.ɵɵFactoryTarget.Component });
+LessOrEqualToFilterOperatorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: LessOrEqualToFilterOperatorComponent, selector: "kendo-treelist-filter-lte-operator", providers: [
+        {
+            provide: FilterOperatorBase,
+            useExisting: forwardRef(() => LessOrEqualToFilterOperatorComponent)
+        }
+    ], usesInheritance: true, ngImport: i0, template: ``, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: LessOrEqualToFilterOperatorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    providers: [
+                        {
+                            provide: FilterOperatorBase,
+                            useExisting: forwardRef(() => LessOrEqualToFilterOperatorComponent)
+                        }
+                    ],
+                    selector: 'kendo-treelist-filter-lte-operator',
+                    template: ``
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }]; } });

package/esm2015/filtering/operators/neq-filter-operator.component.js

@@ -0,0 +1,38 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-l10n";
+/**
+ * Represents the `NotEqual` (**Is not equal to**) filter operator.
+ *
+ * For more information and examples, refer to:
+ * * [Setting the default filter operators]({% slug builtinfiltertemplate_treelist %}#toc-setting-the-default-filter-operator)
+ * * [Setting the order of the filter operators]({% slug builtinfiltertemplate_treelist %}#toc-setting-the-order-of-the-filter-operators)
+ */
+export class NotEqualFilterOperatorComponent extends FilterOperatorBase {
+    constructor(localization) { super("neq", localization); }
+}
+NotEqualFilterOperatorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: NotEqualFilterOperatorComponent, deps: [{ token: i1.LocalizationService }], target: i0.ɵɵFactoryTarget.Component });
+NotEqualFilterOperatorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: NotEqualFilterOperatorComponent, selector: "kendo-treelist-filter-neq-operator", providers: [
+        {
+            provide: FilterOperatorBase,
+            useExisting: forwardRef(() => NotEqualFilterOperatorComponent)
+        }
+    ], usesInheritance: true, ngImport: i0, template: ``, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: NotEqualFilterOperatorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    providers: [
+                        {
+                            provide: FilterOperatorBase,
+                            useExisting: forwardRef(() => NotEqualFilterOperatorComponent)
+                        }
+                    ],
+                    selector: 'kendo-treelist-filter-neq-operator',
+                    template: ``
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }]; } });

package/esm2015/filtering/operators/not-contains-filter-operator.component.js

@@ -0,0 +1,38 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-l10n";
+/**
+ * Represents the `DoesNotContain` (**Does not contain**) filter operator.
+ *
+ * For more information and examples, refer to:
+ * * [Setting the default filter operators]({% slug builtinfiltertemplate_treelist %}#toc-setting-the-default-filter-operator)
+ * * [Setting the order of the filter operators]({% slug builtinfiltertemplate_treelist %}#toc-setting-the-order-of-the-filter-operators)
+ */
+export class DoesNotContainFilterOperatorComponent extends FilterOperatorBase {
+    constructor(localization) { super("doesnotcontain", localization); }
+}
+DoesNotContainFilterOperatorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DoesNotContainFilterOperatorComponent, deps: [{ token: i1.LocalizationService }], target: i0.ɵɵFactoryTarget.Component });
+DoesNotContainFilterOperatorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: DoesNotContainFilterOperatorComponent, selector: "kendo-treelist-filter-not-contains-operator", providers: [
+        {
+            provide: FilterOperatorBase,
+            useExisting: forwardRef(() => DoesNotContainFilterOperatorComponent)
+        }
+    ], usesInheritance: true, ngImport: i0, template: ``, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DoesNotContainFilterOperatorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    providers: [
+                        {
+                            provide: FilterOperatorBase,
+                            useExisting: forwardRef(() => DoesNotContainFilterOperatorComponent)
+                        }
+                    ],
+                    selector: 'kendo-treelist-filter-not-contains-operator',
+                    template: ``
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }]; } });

package/esm2015/filtering/operators/starts-with-filter-operator.component.js

@@ -0,0 +1,38 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import * as i0 from "@angular/core";
+import * as i1 from "@progress/kendo-angular-l10n";
+/**
+ * Represents the `StartsWith` (**Starts with**) filter operator.
+ *
+ * For more information and examples, refer to:
+ * * [Setting the default filter operators]({% slug builtinfiltertemplate_treelist %}#toc-setting-the-default-filter-operator)
+ * * [Setting the order of the filter operators]({% slug builtinfiltertemplate_treelist %}#toc-setting-the-order-of-the-filter-operators)
+ */
+export class StartsWithFilterOperatorComponent extends FilterOperatorBase {
+    constructor(localization) { super("startswith", localization); }
+}
+StartsWithFilterOperatorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: StartsWithFilterOperatorComponent, deps: [{ token: i1.LocalizationService }], target: i0.ɵɵFactoryTarget.Component });
+StartsWithFilterOperatorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: StartsWithFilterOperatorComponent, selector: "kendo-treelist-filter-startswith-operator", providers: [
+        {
+            provide: FilterOperatorBase,
+            useExisting: forwardRef(() => StartsWithFilterOperatorComponent)
+        }
+    ], usesInheritance: true, ngImport: i0, template: ``, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: StartsWithFilterOperatorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    providers: [
+                        {
+                            provide: FilterOperatorBase,
+                            useExisting: forwardRef(() => StartsWithFilterOperatorComponent)
+                        }
+                    ],
+                    selector: 'kendo-treelist-filter-startswith-operator',
+                    template: ``
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }]; } });

package/esm2015/filtering/shared-filtering.module.js

@@ -0,0 +1,149 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ReactiveFormsModule, FormsModule } from '@angular/forms';
+import { DropDownListModule, AutoCompleteModule } from '@progress/kendo-angular-dropdowns';
+import { InputsModule } from '@progress/kendo-angular-inputs';
+import { DatePickerModule } from '@progress/kendo-angular-dateinputs';
+import { PopupModule } from "@progress/kendo-angular-popup";
+import { SharedModule } from '../shared.module';
+import { FilterCellOperatorsComponent } from './cell/filter-cell-operators.component';
+import { FilterInputDirective } from './filter-input.directive';
+import { ContainsFilterOperatorComponent } from './operators/contains-filter-operator.component';
+import { DoesNotContainFilterOperatorComponent } from './operators/not-contains-filter-operator.component';
+import { EndsWithFilterOperatorComponent } from './operators/ends-with-filter-operator.component';
+import { EqualFilterOperatorComponent } from './operators/eq-filter-operator.component';
+import { IsEmptyFilterOperatorComponent } from './operators/is-empty-filter-operator.component';
+import { IsNotEmptyFilterOperatorComponent } from './operators/is-not-empty-filter-operator.component';
+import { IsNotNullFilterOperatorComponent } from './operators/is-not-null-filter-operator.component';
+import { IsNullFilterOperatorComponent } from './operators/isnull-filter-operator.component';
+import { NotEqualFilterOperatorComponent } from './operators/neq-filter-operator.component';
+import { StartsWithFilterOperatorComponent } from './operators/starts-with-filter-operator.component';
+import { GreaterFilterOperatorComponent } from './operators/gt-filter-operator.component';
+import { GreaterOrEqualToFilterOperatorComponent } from './operators/gte-filter-operator.component';
+import { LessFilterOperatorComponent } from './operators/lt-filter-operator.component';
+import { LessOrEqualToFilterOperatorComponent } from './operators/lte-filter-operator.component';
+import { AfterFilterOperatorComponent } from './operators/after-filter-operator.component';
+import { AfterEqFilterOperatorComponent } from './operators/after-eq-filter-operator.component';
+import { BeforeEqFilterOperatorComponent } from './operators/before-eq-filter-operator.component';
+import { BeforeFilterOperatorComponent } from './operators/before-filter-operator.component';
+import * as i0 from "@angular/core";
+const FILTER_OPERATORS = [
+    FilterCellOperatorsComponent,
+    ContainsFilterOperatorComponent,
+    DoesNotContainFilterOperatorComponent,
+    EndsWithFilterOperatorComponent,
+    EqualFilterOperatorComponent,
+    IsEmptyFilterOperatorComponent,
+    IsNotEmptyFilterOperatorComponent,
+    IsNotNullFilterOperatorComponent,
+    IsNullFilterOperatorComponent,
+    NotEqualFilterOperatorComponent,
+    StartsWithFilterOperatorComponent,
+    GreaterFilterOperatorComponent,
+    GreaterOrEqualToFilterOperatorComponent,
+    LessFilterOperatorComponent,
+    LessOrEqualToFilterOperatorComponent,
+    AfterFilterOperatorComponent,
+    AfterEqFilterOperatorComponent,
+    BeforeEqFilterOperatorComponent,
+    BeforeFilterOperatorComponent
+];
+const importedModules = [
+    CommonModule,
+    ReactiveFormsModule,
+    FormsModule,
+    DropDownListModule,
+    AutoCompleteModule,
+    InputsModule,
+    DatePickerModule,
+    PopupModule,
+    SharedModule
+];
+const COMPONENTS = [
+    FilterInputDirective
+];
+/**
+ * @hidden
+ */
+export class SharedFilterModule {
+    static exports() {
+        return [
+            ...FILTER_OPERATORS
+        ];
+    }
+}
+SharedFilterModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SharedFilterModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SharedFilterModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SharedFilterModule, declarations: [FilterCellOperatorsComponent,
+        ContainsFilterOperatorComponent,
+        DoesNotContainFilterOperatorComponent,
+        EndsWithFilterOperatorComponent,
+        EqualFilterOperatorComponent,
+        IsEmptyFilterOperatorComponent,
+        IsNotEmptyFilterOperatorComponent,
+        IsNotNullFilterOperatorComponent,
+        IsNullFilterOperatorComponent,
+        NotEqualFilterOperatorComponent,
+        StartsWithFilterOperatorComponent,
+        GreaterFilterOperatorComponent,
+        GreaterOrEqualToFilterOperatorComponent,
+        LessFilterOperatorComponent,
+        LessOrEqualToFilterOperatorComponent,
+        AfterFilterOperatorComponent,
+        AfterEqFilterOperatorComponent,
+        BeforeEqFilterOperatorComponent,
+        BeforeFilterOperatorComponent, FilterInputDirective], imports: [CommonModule,
+        ReactiveFormsModule,
+        FormsModule,
+        DropDownListModule,
+        AutoCompleteModule,
+        InputsModule,
+        DatePickerModule,
+        PopupModule,
+        SharedModule], exports: [FilterCellOperatorsComponent,
+        ContainsFilterOperatorComponent,
+        DoesNotContainFilterOperatorComponent,
+        EndsWithFilterOperatorComponent,
+        EqualFilterOperatorComponent,
+        IsEmptyFilterOperatorComponent,
+        IsNotEmptyFilterOperatorComponent,
+        IsNotNullFilterOperatorComponent,
+        IsNullFilterOperatorComponent,
+        NotEqualFilterOperatorComponent,
+        StartsWithFilterOperatorComponent,
+        GreaterFilterOperatorComponent,
+        GreaterOrEqualToFilterOperatorComponent,
+        LessFilterOperatorComponent,
+        LessOrEqualToFilterOperatorComponent,
+        AfterFilterOperatorComponent,
+        AfterEqFilterOperatorComponent,
+        BeforeEqFilterOperatorComponent,
+        BeforeFilterOperatorComponent, CommonModule,
+        ReactiveFormsModule,
+        FormsModule,
+        DropDownListModule,
+        AutoCompleteModule,
+        InputsModule,
+        DatePickerModule,
+        PopupModule,
+        SharedModule, FilterInputDirective] });
+SharedFilterModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SharedFilterModule, imports: [[...importedModules], CommonModule,
+        ReactiveFormsModule,
+        FormsModule,
+        DropDownListModule,
+        AutoCompleteModule,
+        InputsModule,
+        DatePickerModule,
+        PopupModule,
+        SharedModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SharedFilterModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [FILTER_OPERATORS, COMPONENTS],
+                    exports: [FILTER_OPERATORS, importedModules, COMPONENTS],
+                    imports: [...importedModules]
+                }]
+        }] });

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

@@ -0,0 +1,82 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+// eslint-disable no-access-missing-member
+import { Component, Input } from '@angular/core';
+import { BaseFilterCellComponent, localizeOperators } from './base-filter-cell.component';
+import { toJSON } from './operators/filter-operator.base';
+import * as i0 from "@angular/core";
+import * as i1 from "./filter.service";
+import * as i2 from "@progress/kendo-angular-l10n";
+const stringOperators = localizeOperators({
+    "filterEqOperator": "eq",
+    "filterNotEqOperator": "neq",
+    "filterContainsOperator": "contains",
+    "filterNotContainsOperator": "doesnotcontain",
+    "filterStartsWithOperator": "startswith",
+    "filterEndsWithOperator": "endswith",
+    "filterIsNullOperator": "isnull",
+    "filterIsNotNullOperator": "isnotnull",
+    "filterIsEmptyOperator": "isempty",
+    "filterIsNotEmptyOperator": "isnotempty"
+});
+/**
+ * Represents a base string filter component.
+ */
+export class StringFilterComponent extends BaseFilterCellComponent {
+    constructor(filterService, localization) {
+        super(filterService);
+        this.localization = localization;
+        /**
+         * The default filter operator. Defaults to `contains`.
+         * @type {string}
+         */
+        this.operator = "contains";
+    }
+    /**
+     * The current filter for the associated column field.
+     * @readonly
+     * @type {FilterDescriptor}
+     */
+    get currentFilter() {
+        return this.filterByField((this.column || {}).field);
+    }
+    /**
+     * The current filter operator for the associated column field.
+     * @readonly
+     * @type {string}
+     */
+    get currentOperator() {
+        return this.currentFilter ? this.currentFilter.operator : this.operator;
+    }
+    ngOnInit() {
+        this.subscription = this.localization.changes.subscribe(this.localizationChange.bind(this));
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+        super.ngOnDestroy();
+    }
+    localizationChange() {
+        this.defaultOperators = stringOperators(this.localization);
+        if (this.operatorList.length) {
+            this.operators = toJSON(this.operatorList.toArray());
+        }
+    }
+}
+StringFilterComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: StringFilterComponent, deps: [{ token: i1.FilterService }, { token: i2.LocalizationService }], target: i0.ɵɵFactoryTarget.Component });
+StringFilterComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: StringFilterComponent, selector: "ng-component", inputs: { column: "column", filter: "filter", operator: "operator" }, usesInheritance: true, ngImport: i0, template: ``, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: StringFilterComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ``
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FilterService }, { type: i2.LocalizationService }]; }, propDecorators: { column: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], operator: [{
+                type: Input
+            }] } });

package/esm2015/kendo-angular-treelist.js

@@ -0,0 +1,8 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './main';

package/esm2015/layout/browser-support.service.js

@@ -0,0 +1,73 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 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 { fromEvent } from 'rxjs';
+import { auditTime } from 'rxjs/operators';
+import { isDocumentAvailable } from '@progress/kendo-angular-common';
+import * as i0 from "@angular/core";
+const canCreateElement = () => isDocumentAvailable() && document.createElement;
+let cachedScrollbarWidth = null;
+let cachedPixelRatio;
+let cachedRtlScrollLeft = null;
+function scrollbarWidth() {
+    if (cachedScrollbarWidth === null && canCreateElement()) {
+        cachedPixelRatio = window.devicePixelRatio || 1;
+        const div = document.createElement("div");
+        div.style.cssText = "overflow:scroll;overflow-x:hidden;zoom:1;clear:both;display:block";
+        div.innerHTML = " ";
+        document.body.appendChild(div);
+        cachedScrollbarWidth = div.offsetWidth - div.scrollWidth;
+        document.body.removeChild(div);
+    }
+    return cachedScrollbarWidth;
+}
+function rtlScrollLeft() {
+    if (cachedRtlScrollLeft === null && canCreateElement()) {
+        const div = document.createElement("div");
+        div.style.cssText = "overflow:scroll;zoom:1;clear:both;display:block;width:100px;visibility:hidden;position:absolute;left:-10000px;direction:rtl;";
+        div.innerHTML = "<div style='width:200px;height:1px;'</div>";
+        document.body.appendChild(div);
+        const initial = div.scrollLeft;
+        div.scrollLeft = -1;
+        cachedRtlScrollLeft = div.scrollLeft < 0 ? div.scrollLeft : initial;
+        document.body.removeChild(div);
+    }
+    return cachedRtlScrollLeft;
+}
+/**
+ * @hidden
+ * move to kendo-common
+ */
+export class BrowserSupportService {
+    constructor(zone, changeDetector) {
+        this.zone = zone;
+        this.changeDetector = changeDetector;
+        this.changes = new EventEmitter();
+        if (typeof window !== 'undefined') {
+            this.zone.runOutsideAngular(() => {
+                fromEvent(window, 'resize').pipe(auditTime(100)).subscribe(() => {
+                    if (cachedPixelRatio !== window.devicePixelRatio) {
+                        zone.run(() => {
+                            cachedScrollbarWidth = null;
+                            this.changes.emit();
+                            this.changeDetector.markForCheck();
+                        });
+                    }
+                });
+            });
+        }
+    }
+    get scrollbarWidth() {
+        return scrollbarWidth();
+    }
+    get rtlScrollLeft() {
+        return rtlScrollLeft();
+    }
+}
+BrowserSupportService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: BrowserSupportService, deps: [{ token: i0.NgZone }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Injectable });
+BrowserSupportService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: BrowserSupportService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: BrowserSupportService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.ChangeDetectorRef }]; } });