@progress/kendo-angular-treelist 3.1.3-dev.202110041229

package/dist/es/filtering/operators/filter-operator.base.js

@@ -0,0 +1,94 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import * as tslib_1 from "tslib";
+import { Input } from '@angular/core';
+import { isNullOrEmptyString } from '../../utils';
+var localizeOperators = function (operators) { return function (localization) {
+    return Object.keys(operators).reduce(function (acc, key) {
+        acc[operators[key]] = localization.get(key);
+        return acc;
+    }, {});
+}; }; // tslint:disable-line:align
+var ɵ0 = localizeOperators;
+var operatorTexts = localizeOperators({
+    "filterEqOperator": "eq",
+    "filterNotEqOperator": "neq",
+    // tslint:disable-next-line:object-literal-sort-keys
+    "filterGteOperator": "gte",
+    "filterGtOperator": "gt",
+    "filterLteOperator": "lte",
+    "filterLtOperator": "lt",
+    "filterIsNullOperator": "isnull",
+    "filterIsNotNullOperator": "isnotnull",
+    "filterIsEmptyOperator": "isempty",
+    "filterIsNotEmptyOperator": "isnotempty",
+    "filterContainsOperator": "contains",
+    "filterNotContainsOperator": "doesnotcontain",
+    "filterStartsWithOperator": "startswith",
+    "filterEndsWithOperator": "endswith",
+    "filterAfterOrEqualOperator": "after-eq",
+    "filterAfterOperator": "after",
+    "filterBeforeOrEqualOperator": "before-eq",
+    "filterBeforeOperator": "before"
+});
+/**
+ * @hidden
+ */
+export var toJSON = function (xs) { return xs.map(function (x) { return x.toJSON(); }); };
+/**
+ * @hidden
+ */
+var FilterOperatorBase = /** @class */ (function () {
+    function FilterOperatorBase(operator, localization) {
+        this.operator = operator;
+        this.localization = localization;
+        this.messages = operatorTexts(this.localization);
+        this._text = this.messages[this.operator];
+        this.localization.changes.subscribe(this.refreshText.bind(this));
+    }
+    Object.defineProperty(FilterOperatorBase.prototype, "text", {
+        /**
+         * The text that will be displayed in the drop-down list.
+         * @readonly
+         * @type {string}
+         * @memberOf FilterOperatorBase
+         */
+        get: function () {
+            return this._text;
+        },
+        /**
+         *
+         */
+        set: function (value) {
+            this._text = isNullOrEmptyString(value) ? this.messages[this.operator] : value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @hidden
+     */
+    FilterOperatorBase.prototype.toJSON = function () {
+        return {
+            text: this.text,
+            value: this.operator
+        };
+    };
+    FilterOperatorBase.prototype.refreshText = function () {
+        var update = this._text === this.messages[this.operator];
+        this.messages = operatorTexts(this.localization);
+        if (update) {
+            this._text = this.messages[this.operator];
+        }
+    };
+    tslib_1.__decorate([
+        Input(),
+        tslib_1.__metadata("design:type", String),
+        tslib_1.__metadata("design:paramtypes", [String])
+    ], FilterOperatorBase.prototype, "text", null);
+    return FilterOperatorBase;
+}());
+export { FilterOperatorBase };
+export { ɵ0 };

package/dist/es/filtering/operators/gt-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 * as tslib_1 from "tslib";
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import { LocalizationService } from '@progress/kendo-angular-l10n';
+/*
+ * Represents the `Greater` (**Is greater 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)
+ */
+var GreaterFilterOperatorComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(GreaterFilterOperatorComponent, _super);
+    function GreaterFilterOperatorComponent(localization) {
+        return _super.call(this, "gt", localization) || this;
+    }
+    GreaterFilterOperatorComponent_1 = GreaterFilterOperatorComponent;
+    var GreaterFilterOperatorComponent_1;
+    GreaterFilterOperatorComponent = GreaterFilterOperatorComponent_1 = tslib_1.__decorate([
+        Component({
+            providers: [
+                {
+                    provide: FilterOperatorBase,
+                    useExisting: forwardRef(function () { return GreaterFilterOperatorComponent_1; })
+                }
+            ],
+            selector: 'kendo-treelist-filter-gt-operator',
+            template: ""
+        }),
+        tslib_1.__metadata("design:paramtypes", [LocalizationService])
+    ], GreaterFilterOperatorComponent);
+    return GreaterFilterOperatorComponent;
+}(FilterOperatorBase));
+export { GreaterFilterOperatorComponent };

package/dist/es/filtering/operators/gte-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 * as tslib_1 from "tslib";
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import { LocalizationService } from '@progress/kendo-angular-l10n';
+/**
+ * Represents the `GreaterOrEqualTo` (**Is greater 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)
+ */
+var GreaterOrEqualToFilterOperatorComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(GreaterOrEqualToFilterOperatorComponent, _super);
+    function GreaterOrEqualToFilterOperatorComponent(localization) {
+        return _super.call(this, "gte", localization) || this;
+    }
+    GreaterOrEqualToFilterOperatorComponent_1 = GreaterOrEqualToFilterOperatorComponent;
+    var GreaterOrEqualToFilterOperatorComponent_1;
+    GreaterOrEqualToFilterOperatorComponent = GreaterOrEqualToFilterOperatorComponent_1 = tslib_1.__decorate([
+        Component({
+            providers: [
+                {
+                    provide: FilterOperatorBase,
+                    useExisting: forwardRef(function () { return GreaterOrEqualToFilterOperatorComponent_1; })
+                }
+            ],
+            selector: 'kendo-treelist-filter-gte-operator',
+            template: ""
+        }),
+        tslib_1.__metadata("design:paramtypes", [LocalizationService])
+    ], GreaterOrEqualToFilterOperatorComponent);
+    return GreaterOrEqualToFilterOperatorComponent;
+}(FilterOperatorBase));
+export { GreaterOrEqualToFilterOperatorComponent };

package/dist/es/filtering/operators/is-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 * as tslib_1 from "tslib";
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import { LocalizationService } from '@progress/kendo-angular-l10n';
+/**
+ * Represents the `IsEmpty` (**Is 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)
+ */
+var IsEmptyFilterOperatorComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(IsEmptyFilterOperatorComponent, _super);
+    function IsEmptyFilterOperatorComponent(localization) {
+        return _super.call(this, "isempty", localization) || this;
+    }
+    IsEmptyFilterOperatorComponent_1 = IsEmptyFilterOperatorComponent;
+    var IsEmptyFilterOperatorComponent_1;
+    IsEmptyFilterOperatorComponent = IsEmptyFilterOperatorComponent_1 = tslib_1.__decorate([
+        Component({
+            providers: [
+                {
+                    provide: FilterOperatorBase,
+                    useExisting: forwardRef(function () { return IsEmptyFilterOperatorComponent_1; })
+                }
+            ],
+            selector: 'kendo-treelist-filter-isempty-operator',
+            template: ""
+        }),
+        tslib_1.__metadata("design:paramtypes", [LocalizationService])
+    ], IsEmptyFilterOperatorComponent);
+    return IsEmptyFilterOperatorComponent;
+}(FilterOperatorBase));
+export { IsEmptyFilterOperatorComponent };

package/dist/es/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 * as tslib_1 from "tslib";
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import { LocalizationService } 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)
+ */
+var IsNotEmptyFilterOperatorComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(IsNotEmptyFilterOperatorComponent, _super);
+    function IsNotEmptyFilterOperatorComponent(localization) {
+        return _super.call(this, "isnotempty", localization) || this;
+    }
+    IsNotEmptyFilterOperatorComponent_1 = IsNotEmptyFilterOperatorComponent;
+    var IsNotEmptyFilterOperatorComponent_1;
+    IsNotEmptyFilterOperatorComponent = IsNotEmptyFilterOperatorComponent_1 = tslib_1.__decorate([
+        Component({
+            providers: [
+                {
+                    provide: FilterOperatorBase,
+                    useExisting: forwardRef(function () { return IsNotEmptyFilterOperatorComponent_1; })
+                }
+            ],
+            selector: 'kendo-treelist-filter-isnotempty-operator',
+            template: ""
+        }),
+        tslib_1.__metadata("design:paramtypes", [LocalizationService])
+    ], IsNotEmptyFilterOperatorComponent);
+    return IsNotEmptyFilterOperatorComponent;
+}(FilterOperatorBase));
+export { IsNotEmptyFilterOperatorComponent };

package/dist/es/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 * as tslib_1 from "tslib";
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import { LocalizationService } 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)
+ */
+var IsNotNullFilterOperatorComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(IsNotNullFilterOperatorComponent, _super);
+    function IsNotNullFilterOperatorComponent(localization) {
+        return _super.call(this, "isnotnull", localization) || this;
+    }
+    IsNotNullFilterOperatorComponent_1 = IsNotNullFilterOperatorComponent;
+    var IsNotNullFilterOperatorComponent_1;
+    IsNotNullFilterOperatorComponent = IsNotNullFilterOperatorComponent_1 = tslib_1.__decorate([
+        Component({
+            providers: [
+                {
+                    provide: FilterOperatorBase,
+                    useExisting: forwardRef(function () { return IsNotNullFilterOperatorComponent_1; })
+                }
+            ],
+            selector: 'kendo-treelist-filter-isnotnull-operator',
+            template: ""
+        }),
+        tslib_1.__metadata("design:paramtypes", [LocalizationService])
+    ], IsNotNullFilterOperatorComponent);
+    return IsNotNullFilterOperatorComponent;
+}(FilterOperatorBase));
+export { IsNotNullFilterOperatorComponent };

package/dist/es/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 * as tslib_1 from "tslib";
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import { LocalizationService } 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)
+ */
+var IsNullFilterOperatorComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(IsNullFilterOperatorComponent, _super);
+    function IsNullFilterOperatorComponent(localization) {
+        return _super.call(this, "isnull", localization) || this;
+    }
+    IsNullFilterOperatorComponent_1 = IsNullFilterOperatorComponent;
+    var IsNullFilterOperatorComponent_1;
+    IsNullFilterOperatorComponent = IsNullFilterOperatorComponent_1 = tslib_1.__decorate([
+        Component({
+            providers: [
+                {
+                    provide: FilterOperatorBase,
+                    useExisting: forwardRef(function () { return IsNullFilterOperatorComponent_1; })
+                }
+            ],
+            selector: 'kendo-treelist-filter-isnull-operator',
+            template: ""
+        }),
+        tslib_1.__metadata("design:paramtypes", [LocalizationService])
+    ], IsNullFilterOperatorComponent);
+    return IsNullFilterOperatorComponent;
+}(FilterOperatorBase));
+export { IsNullFilterOperatorComponent };

package/dist/es/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 * as tslib_1 from "tslib";
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import { LocalizationService } 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)
+ */
+var LessFilterOperatorComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(LessFilterOperatorComponent, _super);
+    function LessFilterOperatorComponent(localization) {
+        return _super.call(this, "lt", localization) || this;
+    }
+    LessFilterOperatorComponent_1 = LessFilterOperatorComponent;
+    var LessFilterOperatorComponent_1;
+    LessFilterOperatorComponent = LessFilterOperatorComponent_1 = tslib_1.__decorate([
+        Component({
+            providers: [
+                {
+                    provide: FilterOperatorBase,
+                    useExisting: forwardRef(function () { return LessFilterOperatorComponent_1; })
+                }
+            ],
+            selector: 'kendo-treelist-filter-lt-operator',
+            template: ""
+        }),
+        tslib_1.__metadata("design:paramtypes", [LocalizationService])
+    ], LessFilterOperatorComponent);
+    return LessFilterOperatorComponent;
+}(FilterOperatorBase));
+export { LessFilterOperatorComponent };

package/dist/es/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 * as tslib_1 from "tslib";
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import { LocalizationService } 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)
+ */
+var LessOrEqualToFilterOperatorComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(LessOrEqualToFilterOperatorComponent, _super);
+    function LessOrEqualToFilterOperatorComponent(localization) {
+        return _super.call(this, "lte", localization) || this;
+    }
+    LessOrEqualToFilterOperatorComponent_1 = LessOrEqualToFilterOperatorComponent;
+    var LessOrEqualToFilterOperatorComponent_1;
+    LessOrEqualToFilterOperatorComponent = LessOrEqualToFilterOperatorComponent_1 = tslib_1.__decorate([
+        Component({
+            providers: [
+                {
+                    provide: FilterOperatorBase,
+                    useExisting: forwardRef(function () { return LessOrEqualToFilterOperatorComponent_1; })
+                }
+            ],
+            selector: 'kendo-treelist-filter-lte-operator',
+            template: ""
+        }),
+        tslib_1.__metadata("design:paramtypes", [LocalizationService])
+    ], LessOrEqualToFilterOperatorComponent);
+    return LessOrEqualToFilterOperatorComponent;
+}(FilterOperatorBase));
+export { LessOrEqualToFilterOperatorComponent };

package/dist/es/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 * as tslib_1 from "tslib";
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import { LocalizationService } 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)
+ */
+var NotEqualFilterOperatorComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(NotEqualFilterOperatorComponent, _super);
+    function NotEqualFilterOperatorComponent(localization) {
+        return _super.call(this, "neq", localization) || this;
+    }
+    NotEqualFilterOperatorComponent_1 = NotEqualFilterOperatorComponent;
+    var NotEqualFilterOperatorComponent_1;
+    NotEqualFilterOperatorComponent = NotEqualFilterOperatorComponent_1 = tslib_1.__decorate([
+        Component({
+            providers: [
+                {
+                    provide: FilterOperatorBase,
+                    useExisting: forwardRef(function () { return NotEqualFilterOperatorComponent_1; })
+                }
+            ],
+            selector: 'kendo-treelist-filter-neq-operator',
+            template: ""
+        }),
+        tslib_1.__metadata("design:paramtypes", [LocalizationService])
+    ], NotEqualFilterOperatorComponent);
+    return NotEqualFilterOperatorComponent;
+}(FilterOperatorBase));
+export { NotEqualFilterOperatorComponent };

package/dist/es/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 * as tslib_1 from "tslib";
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import { LocalizationService } 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)
+ */
+var DoesNotContainFilterOperatorComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(DoesNotContainFilterOperatorComponent, _super);
+    function DoesNotContainFilterOperatorComponent(localization) {
+        return _super.call(this, "doesnotcontain", localization) || this;
+    }
+    DoesNotContainFilterOperatorComponent_1 = DoesNotContainFilterOperatorComponent;
+    var DoesNotContainFilterOperatorComponent_1;
+    DoesNotContainFilterOperatorComponent = DoesNotContainFilterOperatorComponent_1 = tslib_1.__decorate([
+        Component({
+            providers: [
+                {
+                    provide: FilterOperatorBase,
+                    useExisting: forwardRef(function () { return DoesNotContainFilterOperatorComponent_1; })
+                }
+            ],
+            selector: 'kendo-treelist-filter-not-contains-operator',
+            template: ""
+        }),
+        tslib_1.__metadata("design:paramtypes", [LocalizationService])
+    ], DoesNotContainFilterOperatorComponent);
+    return DoesNotContainFilterOperatorComponent;
+}(FilterOperatorBase));
+export { DoesNotContainFilterOperatorComponent };

package/dist/es/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 * as tslib_1 from "tslib";
+import { Component, forwardRef } from '@angular/core';
+import { FilterOperatorBase } from './filter-operator.base';
+import { LocalizationService } 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)
+ */
+var StartsWithFilterOperatorComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(StartsWithFilterOperatorComponent, _super);
+    function StartsWithFilterOperatorComponent(localization) {
+        return _super.call(this, "startswith", localization) || this;
+    }
+    StartsWithFilterOperatorComponent_1 = StartsWithFilterOperatorComponent;
+    var StartsWithFilterOperatorComponent_1;
+    StartsWithFilterOperatorComponent = StartsWithFilterOperatorComponent_1 = tslib_1.__decorate([
+        Component({
+            providers: [
+                {
+                    provide: FilterOperatorBase,
+                    useExisting: forwardRef(function () { return StartsWithFilterOperatorComponent_1; })
+                }
+            ],
+            selector: 'kendo-treelist-filter-startswith-operator',
+            template: ""
+        }),
+        tslib_1.__metadata("design:paramtypes", [LocalizationService])
+    ], StartsWithFilterOperatorComponent);
+    return StartsWithFilterOperatorComponent;
+}(FilterOperatorBase));
+export { StartsWithFilterOperatorComponent };

package/dist/es/filtering/shared-filtering.module.js

@@ -0,0 +1,87 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import * as tslib_1 from "tslib";
+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';
+var FILTER_OPERATORS = [
+    FilterCellOperatorsComponent,
+    ContainsFilterOperatorComponent,
+    DoesNotContainFilterOperatorComponent,
+    EndsWithFilterOperatorComponent,
+    EqualFilterOperatorComponent,
+    IsEmptyFilterOperatorComponent,
+    IsNotEmptyFilterOperatorComponent,
+    IsNotNullFilterOperatorComponent,
+    IsNullFilterOperatorComponent,
+    NotEqualFilterOperatorComponent,
+    StartsWithFilterOperatorComponent,
+    GreaterFilterOperatorComponent,
+    GreaterOrEqualToFilterOperatorComponent,
+    LessFilterOperatorComponent,
+    LessOrEqualToFilterOperatorComponent,
+    AfterFilterOperatorComponent,
+    AfterEqFilterOperatorComponent,
+    BeforeEqFilterOperatorComponent,
+    BeforeFilterOperatorComponent
+];
+var importedModules = [
+    CommonModule,
+    ReactiveFormsModule,
+    FormsModule,
+    DropDownListModule,
+    AutoCompleteModule,
+    InputsModule,
+    DatePickerModule,
+    PopupModule,
+    SharedModule
+];
+var COMPONENTS = [
+    FilterInputDirective
+];
+/**
+ * @hidden
+ */
+var SharedFilterModule = /** @class */ (function () {
+    function SharedFilterModule() {
+    }
+    SharedFilterModule.exports = function () {
+        return FILTER_OPERATORS.slice();
+    };
+    SharedFilterModule = tslib_1.__decorate([
+        NgModule({
+            declarations: [FILTER_OPERATORS, COMPONENTS],
+            exports: [FILTER_OPERATORS, importedModules, COMPONENTS],
+            imports: importedModules.slice()
+        })
+    ], SharedFilterModule);
+    return SharedFilterModule;
+}());
+export { SharedFilterModule };