@syncfusion/ej2-angular-treegrid 31.2.5-ngcc → 31.2.5

package/CHANGELOG.md

@@ -0,0 +1,214 @@
+# Changelog
+
+## [Unreleased]
+
+## 31.1.22 (2025-10-01)
+
+### Tree Grid
+
+#### Bug Fixes
+
+- `#763935` - Fixed an issue where the child records position were wrong when expanding parent record in remote data case.
+
+## 31.1.20 (2025-09-10)
+
+### Tree Grid
+
+#### Bug Fixes
+
+-`#I759266` - The `addRecord` method of the TreeGrid correctly adds a child record to the specified parent node.- `#F69767` - Fixed an issue where data was being duplicated when dragging and dropping items and refreshing in the treegrid.
+
+## 31.1.17 (2025-09-05)
+
+### Tree Grid
+
+#### Features
+
+- Introduced sticky header support in the Tree Grid, allowing column headers to stay fixed during scrolling. This improves navigation and readability in large hierarchical data views. Explore the demo [here](https://ej2.syncfusion.com/demos/#/tailwind3/tree-grid/sticky-header.html).
+
+- Enhanced support for `LoadChildOnDemand` in the Tree Grid with remote data binding and virtual scrolling. This improvement enables efficient, on-demand retrieval of child records, ensuring smoother performance when working with large hierarchical datasets.
+
+- Introduced sticky header support in the Tree Grid, allowing column headers to stay fixed during scrolling. This improves navigation and readability in large hierarchical data views. Explore the demo [here](https://ej2.syncfusion.com/angular/demos/#/tailwind3/treegrid/stickyheader).
+
+- Enhanced support for `LoadChildOnDemand` in the Tree Grid with remote data binding and virtual scrolling. This improvement enables efficient, on-demand retrieval of child records, ensuring smoother performance when working with large hierarchical datasets.
+
+## 20.2.36 (2022-06-30)
+
+### Tree Grid
+
+#### Features
+
+- Provided support for inline editing with virtualization enabled. Please find the demo [here](https://ej2.syncfusion.com/demos/#/bootstrap5/tree-grid/virtual-scrolling.html).
+- `#I323425`, `#I332700`, `#I344742`, `#I375307` - Provided support for frozen column with virtualization enabled.
+
+- `#I334966`, `#I373929`, `#I332693`, `#I342835`, `#F172606`, `#F171250`, `#F171248` - Provided row drag and drop support with virtualization feature enabled.
+- `#I367483` - Provided support for row indent and outdent functionality. Please find the demo link [here](https://ej2.syncfusion.com/angular/demos/#/bootstrap5/treegrid/inlineediting).
+
+## 19.2.44 (2021-06-30)
+
+### Tree Grid
+
+#### Bug Fixes
+
+- `#332604` - Resolved white space issue while using less number of records with Virtualization.
+
+- `#I329350` - Immutable mode works fine for date values and row reordering.
+- `#I329988`, `#I331155` - Editing a newly added child record works fine with self referential data.
+
+## 18.4.30 (2020-12-17)
+
+### Tree Grid
+
+#### New Features
+
+- `#294082` - Provided Immutable Support to refresh specific rows while perform Tree Grid actions.
+- `#283491` - Provided error handling support to easily rectify errors in sample side.
+- `#298682`, `#299561` - Added getVisibleRecords API to get the visible records based on collapsed rows state.
+
+#### Bug Fixes
+
+- `#F157882`- After editing the row using `updateRow` method, `getCurrentViewRecords` method updated properly.
+- `#F157882`- When editing with a double click, it works fine when we only have one record.
+- `#289600` - Records get expanded properly after collapsing all records using `collapseAtLevel` method in observable binding.
+- `#F157099` - Virtualization with Aggregates works fine with large number of records.
+- `#296233` - Row Drag and Drop within treegrid works fine.
+- `#297986` - Row Drag and drop within treegrid works fine with checkbox enabled.
+- `#F158886` - Cell editing with frozen columns works fine.
+- `#299761` - Treegrid column width renders fine in Internet Explorer when Virtualization is enabled.
+- `#301861` - Tree Grid dataSource updated properly while using setCellValue method.
+- `#F159697` -  Order of child records are displayed correctly after editing in remote data binding.
+- `292453` - Treegrid refresh method works fine after updating the data.
+
+- `#289600` - Records get expanded properly after collapsing all records using `collapseAtLevel` method in observable binding.
+- `#F157099` - Virtualization with Aggregates works fine with large number of records.
+- `#297986` - Row Drag and drop within treegrid works fine with checkbox enabled.
+- `#F158886` - Cell editing with frozen columns works fine.
+- `#F159697` -  Order of child records are displayed correctly after editing in remote data binding.
+
+## 18.3.35 (2020-10-01)
+
+### TreeGrid
+
+#### Bug Fixes
+
+- `#F157258` - `updateRow` method works fine for updating collapsed data.
+- `#292933` - checkbox rendered properly while using  the template column.
+- `#289685` - Aggregate Column Formatting is working fine
+- `#288542` - The Expand / Collapse icon has been rendered properly while enabling expand state mapping and adding a new record.
+- `#287235` - While enabling expand state mapping the Expand / Collapse icon works fine at nested child levels.
+- `#285434`- Column SortComparer function works fine with null values for RemoteSaveAdaptor datasource.
+- `#284987`- Records rendered properly while using remote save adaptor in created event.
+- `#285434`- Column SortComparer function works fine with null values in datasource.
+- `#F155077`- Records rendered properly while using remote data with jQuery unobtrusive library.
+
+- `#F157258` - `updateRow` method works fine for updating collapsed data.
+
+## 18.2.44 (2020-07-07)
+
+### TreeGrid
+
+#### Bug Fixes
+
+- `#279109` - Checkbox checked properly for child records in remote data.
+- `#277364`, `#279732` - Checkbox with `allowRowDragAndDrop` property rendered properly after editing and cancelling in cell edit mode.
+- `#277364` - Checkbox with `autoCheckHierarchy` property rendered properly after editing and cancelling in cell edit mode.
+- `#278266` - Edit type `dropdownedit` is working properly in cell edit mode when enter key is pressed.
+- `#272026` - `updateRow` method works fine for updating treegrid data source.
+- `#273309` - Editing the zeroth level added record works fine in Batch mode.
+- `#277361` - Auto generated columns work fine when two treegrids are rendered on the same page.
+
+- `F153495` - Sorting after editing is working fine with cell edit mode.
+- `#266963`- Drag and drop works fine in unordered list of data.
+- `#F151795` - Localization support works fine in Add row, Above, Below Context Menu Items.
+- `#F151795`- In Drag and drop, while dropping at first row, its border color is changed properly.
+
+#### New Features
+
+- `#258863`, `#271677` - Expand & Collapse child rows support has been provided in Excel Export.
+- Columnchooser support has been provided that allows user to show or hide columns dynamically.
+- Provided support for Editing with Virtualization feature.
+
+#### Breaking Changes
+
+- Now `data`, `row` these Tree Grid selection event arguments are get array values only when we perform multi selection. Please find modified event arguments and it types from the below table,
+
+`Properties` |`Type`
+-----|-----
+`data` | `Object or Object[]`
+`rowIndex` | `number`
+`rowIndexes` | `number[]`
+`row` | `Element or Element[]`
+
+## 17.4.39 (2019-12-17)
+
+### TreeGrid
+
+#### New Features
+
+- AutoFill support has been provided that allows users to copy the data of selected cells and paste it to another cells by dragging.
+
+#### Breaking Changes
+
+- Default value of column's `disableHtmlEncode` is set to true, so the HTML tags can be displayed in the Grid header and content by default. To display it as html content `disableHtmlEncode` need to be set as false.
+
+#### Bug Fixes
+
+- `#148913` - Expand icon displays properly for the nested records in Custom Data Binding.
+
+## 17.2.48-beta (2019-08-28)
+
+### TreeGrid
+
+#### New Features
+
+- Checkbox selection support has been provided that allows users to select rows using checkbox.
+- Checkbox Column support has been provided that allows users to check rows using checkbox in treegrid column.
+
+#### Bug Fixes
+
+- Change detection for properties `dataSource` and `query` were handled for remote data.
+- Edited records can be searched/filtered.
+- Inner level records will be collapsed/expanded after filtering/searching actions.
+
+## 17.1.1-beta (2019-01-29)
+
+### TreeGrid
+
+#### Bug Fixes
+
+- `Query` maintenance support provided for `refresh` method after expanding any child rows.
+- Property change support for `height` property has been provided.
+- Expand icon is prevented from displaying for the root/zeroth level record which has `hasChildMapping` field as false.
+- Child records of third level or its successor displays properly based on their hierarchy relation in self reference data binding.
+
+- Expand icon is prevented from displaying for the root/zeroth level record which has `hasChildMapping` field as false.
+
+#### New Features
+
+- `Excel-Like Filtering` support is provided that allows users to create complex filter criteria for a column by allowing users to select possible filter values from a checkbox list. The advanced filter can be used to build complex filter criteria.
+
+## 16.4.45 (2019-01-02)
+
+### TreeGrid
+
+#### Bug Fixes
+
+- Added events for the column menu feature and added `columnMenuItems` API to modify the column menu items in column menu.
+- Added `sortComparer` API to perform custom sorting in TreeGrid.
+
+## 16.4.44 (2018-12-24)
+
+### TreeGrid
+
+#### Bug Fixes
+
+- Expanding and Collapsing records is working fine when `pageSizeMode` is set as `All`.
+- `expandAtLevel`, `collapseAtLevel`, `expandAll` and `collapseAll` methods are working fine when `pageSizeMode` is set as `All`.- `actionBegin`, `actionComplete` and `actionFailure` events are triggered properly.
+- Additional parameters that are added using the `query` property of TreeGrid are passed to the server side when a parent record is expanded.## 19.1.54 (2021-03-30)
+
+### Tree Grid
+
+#### Bug Fixes
+
+- `#332604` - Resolved white space issue while using less number of records with Virtualization.
+

package/README.md

@@ -14,7 +14,7 @@ The [Angular TreeGrid](https://www.syncfusion.com/angular-components/angular-tre
 <p align="center">
 Trusted by the world's leading companies
   <a href="https://www.syncfusion.com">
-    <img src="https://raw.githubusercontent.com/SyncfusionExamples/nuget-img/master/syncfusion/syncfusion-trusted-companies.webp" alt="Bootstrap logo">
+    <img src="https://ej2.syncfusion.com/home/images/trusted_companies.png" alt="Bootstrap logo">
   </a>
 </p>
 
@@ -35,9 +35,9 @@ ng new my-app
 cd my-app
 ```
 
-### Adding Syncfusion Tree Grid package
+### Adding Syncfusion<sup>®</sup> Tree Grid package
 
-All Syncfusion angular packages are published in [npmjs.com](https://www.npmjs.com/~syncfusionorg) registry. To install angular tree grid package, use the following command.
+All Syncfusion<sup>®</sup> angular packages are published in [npmjs.com](https://www.npmjs.com/~syncfusionorg) registry. To install angular tree grid package, use the following command.
 
 ```bash
 ng add @syncfusion/ej2-angular-treegrid
@@ -47,13 +47,13 @@ The above command does the below configuration to your Angular app.
  
  * Adds `@syncfusion/ej2-angular-treegrid` package and its peer dependencies to your `package.json` file.
  * Imports the `TreeGridModule` in your application module `app.module.ts`.
- * Registers the Syncfusion UI default theme (material) in the `angular.json` file.
+ * Registers the Syncfusion<sup>®</sup> UI default theme (material) in the `angular.json` file.
 
-This makes it easy to add the Syncfusion Angular TreeGrid module to your project and start using it in your application.
+This makes it easy to add the Syncfusion<sup>®</sup> Angular TreeGrid module to your project and start using it in your application.
 
 ### Add Tree Grid Component
 
-In **src/app/app.component.ts**, use `<ejs-treegrid>` selector in `template` attribute of  `@Component` directive to render the Syncfusion Angular TreeGrid component.
+In **src/app/app.component.ts**, use `<ejs-treegrid>` selector in `template` attribute of  `@Component` directive to render the Syncfusion<sup>®</sup> Angular TreeGrid component.
 
 ```typescript
 import { Component, OnInit } from '@angular/core';
@@ -124,6 +124,14 @@ TreeGrid component is also offered in the following list of frameworks.
 * [RTL support](https://ej2.syncfusion.com/angular/documentation/treegrid/global-local/#right-to-left-rtl): Provides the right-to-left mode which aligns content in the TreeGrid component from right to left. This improves user experience and accessibility for those who work with RTL languages like Hebrew and Arabic.
 * [Localization](https://ej2.syncfusion.com/angular/documentation/treegrid/global-local/#localization): Provides inherent support to localize the UI.
 
+## Resources
+
+* [Documentation](https://ej2.syncfusion.com/angular/documentation/treegrid/overview)
+* [Theme Studio](https://ej2.syncfusion.com/themestudio/)
+* [What's New](https://www.syncfusion.com/products/whatsnew/angular?utm_medium=listing&utm_source=github)
+* [Road Map](https://www.syncfusion.com/products/roadmap/angular)
+* [E-Books](https://www.syncfusion.com/succinctly-free-ebooks?searchkey=angular&type=all)
+
 ## Support
 
 Product support is available through the following mediums.
@@ -140,7 +148,7 @@ Check the changelog [here](https://github.com/syncfusion/ej2-angular-ui-componen
 
 ## License and copyright
 
-> This is a commercial product and requires a paid license for possession or use. Syncfusion’s licensed software, including this component, is subject to the terms and conditions of Syncfusion's [EULA](https://www.syncfusion.com/eula/es/). To acquire a license for 80+ [Angular UI components](https://www.syncfusion.com/angular-components), you can [purchase](https://www.syncfusion.com/sales/products) or [start a free 30-day trial](https://www.syncfusion.com/account/manage-trials/start-trials).
+> This is a commercial product and requires a paid license for possession or use. Syncfusion’s licensed software, including this component, is subject to the terms and conditions of Syncfusion's [EULA](https://www.syncfusion.com/eula/es/). To acquire a license for 140+ [Angular UI components](https://www.syncfusion.com/angular-components), you can [purchase](https://www.syncfusion.com/sales/products) or [start a free 30-day trial](https://www.syncfusion.com/account/manage-trials/start-trials).
 
 > A free community [license](https://www.syncfusion.com/products/communitylicense) is also available for companies and individuals whose organizations have less than $1 million USD in annual gross revenue and five or fewer developers.
 

package/esm2020/public_api.mjs

@@ -0,0 +1,2 @@
+export * from './src/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NyYy9pbmRleCc7Il19

package/esm2020/src/index.mjs

@@ -0,0 +1,9 @@
+export { StackedColumnDirective, StackedColumnsDirective } from './treegrid/stacked-column.directive';
+export { ColumnDirective, ColumnsDirective } from './treegrid/columns.directive';
+export { AggregateColumnDirective, AggregateColumnsDirective } from './treegrid/aggregate-columns.directive';
+export { AggregateDirective, AggregatesDirective } from './treegrid/aggregates.directive';
+export { TreeGridComponent } from './treegrid/treegrid.component';
+export { TreeGridModule } from './treegrid/treegrid.module';
+export { TreeGridAllModule, FilterService, PageService, SortService, ReorderService, ToolbarService, AggregateService, ResizeService, ColumnMenuService, ExcelExportService, PdfExportService, CommandColumnService, ContextMenuService, EditService, SelectionService, VirtualScrollService, DetailRowService, RowDDService, FreezeService, ColumnChooserService, LoggerService, InfiniteScrollService } from './treegrid/treegrid-all.module';
+export * from '@syncfusion/ej2-treegrid';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/treegrid/aggregate-columns.directive.mjs

@@ -0,0 +1,72 @@
+import { __decorate } from "tslib";
+import { Directive, ContentChildren, ContentChild } from '@angular/core';
+import { ComplexBase, ArrayBase, setValue } from '@syncfusion/ej2-angular-base';
+import { Template } from '@syncfusion/ej2-angular-base';
+import * as i0 from "@angular/core";
+let input = ['columnName', 'customAggregate', 'field', 'footerTemplate', 'format', 'type'];
+let outputs = [];
+/**
+ * `e-aggregate->e-column` directive represent a aggregate column of the Angular TreeGrid.
+ * ```html
+ * <ejs-treegrid [dataSource]='data' allowPaging='true' allowSorting='true'>
+ *   <e-columns>
+ *     <e-column field='ID' width='100'></e-column>
+ *     <e-column field='name' headerText='Name' width='100'></e-column>
+ *   </e-columns>
+ *   <e-aggregates>
+ *     <e-aggregate>
+ *       <e-columns>
+ *         <e-column field='ID' type='Min'></e-column>
+ *       </e-columns>
+ *      </e-aggregate>
+ *    </e-aggregates>
+ * </ejs-treegrid>
+ * ```
+ */
+export class AggregateColumnDirective extends ComplexBase {
+    constructor(viewContainerRef) {
+        super();
+        this.viewContainerRef = viewContainerRef;
+        setValue('currentInstance', this, this.viewContainerRef);
+        this.registerEvents(outputs);
+        this.directivePropList = input;
+    }
+}
+AggregateColumnDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AggregateColumnDirective, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+AggregateColumnDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.3", type: AggregateColumnDirective, selector: "ejs-treegrid>e-aggregates>e-aggregate>e-columns>e-column", inputs: { columnName: "columnName", customAggregate: "customAggregate", field: "field", footerTemplate: "footerTemplate", format: "format", type: "type" }, queries: [{ propertyName: "footerTemplate", first: true, predicate: ["footerTemplate"], descendants: true }], usesInheritance: true, ngImport: i0 });
+__decorate([
+    Template()
+], AggregateColumnDirective.prototype, "footerTemplate", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AggregateColumnDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ejs-treegrid>e-aggregates>e-aggregate>e-columns>e-column',
+                    inputs: input,
+                    outputs: outputs,
+                    queries: {}
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }]; }, propDecorators: { footerTemplate: [{
+                type: ContentChild,
+                args: ['footerTemplate']
+            }] } });
+/**
+ * AggregateColumn Array Directive
+ * @private
+ */
+export class AggregateColumnsDirective extends ArrayBase {
+    constructor() {
+        super('columns');
+    }
+}
+AggregateColumnsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AggregateColumnsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+AggregateColumnsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.3", type: AggregateColumnsDirective, selector: "ejs-treegrid>e-aggregates>e-aggregate>e-columns", queries: [{ propertyName: "children", predicate: AggregateColumnDirective }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AggregateColumnsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ejs-treegrid>e-aggregates>e-aggregate>e-columns',
+                    queries: {
+                        children: new ContentChildren(AggregateColumnDirective)
+                    },
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/treegrid/aggregates.directive.mjs

@@ -0,0 +1,69 @@
+import { Directive, ContentChildren, ContentChild } from '@angular/core';
+import { ComplexBase, ArrayBase, setValue } from '@syncfusion/ej2-angular-base';
+import { AggregateColumnsDirective } from './aggregate-columns.directive';
+import * as i0 from "@angular/core";
+let input = ['columns', 'showChildSummary'];
+let outputs = [];
+/**
+ * `e-aggregate` directive represent a aggregate row of the Angular TreeGrid.
+ * It must be contained in a TreeGrid component(`ejs-treegrid`).
+ * ```html
+ * <ejs-treegrid [dataSource]='data' allowPaging='true' allowSorting='true'>
+ *   <e-columns>
+ *     <e-column field='ID' width='100'></e-column>
+ *     <e-column field='name' headerText='Name' width='100'></e-column>
+ *   </e-columns>
+ *   <e-aggregates>
+ *     <e-aggregate>
+ *       <e-columns>
+ *         <e-column field='ID' type='Min'></e-column>
+ *       </e-columns>
+ *      </e-aggregate>
+ *    </e-aggregates>
+ * </ejs-treegrid>
+ * ```
+ */
+export class AggregateDirective extends ComplexBase {
+    constructor(viewContainerRef) {
+        super();
+        this.viewContainerRef = viewContainerRef;
+        this.tags = ['columns'];
+        setValue('currentInstance', this, this.viewContainerRef);
+        this.registerEvents(outputs);
+        this.directivePropList = input;
+    }
+}
+AggregateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AggregateDirective, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+AggregateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.3", type: AggregateDirective, selector: "ejs-treegrid>e-aggregates>e-aggregate", inputs: { columns: "columns", showChildSummary: "showChildSummary" }, queries: [{ propertyName: "childColumns", first: true, predicate: AggregateColumnsDirective, descendants: true }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AggregateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ejs-treegrid>e-aggregates>e-aggregate',
+                    inputs: input,
+                    outputs: outputs,
+                    queries: {
+                        childColumns: new ContentChild(AggregateColumnsDirective)
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }]; } });
+/**
+ * Aggregate Array Directive
+ * @private
+ */
+export class AggregatesDirective extends ArrayBase {
+    constructor() {
+        super('aggregates');
+    }
+}
+AggregatesDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AggregatesDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+AggregatesDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.3", type: AggregatesDirective, selector: "ejs-treegrid>e-aggregates", queries: [{ propertyName: "children", predicate: AggregateDirective }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: AggregatesDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ejs-treegrid>e-aggregates',
+                    queries: {
+                        children: new ContentChildren(AggregateDirective)
+                    },
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/treegrid/columns.directive.mjs

@@ -0,0 +1,100 @@
+import { __decorate } from "tslib";
+import { Directive, ContentChildren, ContentChild } from '@angular/core';
+import { ComplexBase, ArrayBase, setValue } from '@syncfusion/ej2-angular-base';
+import { Template } from '@syncfusion/ej2-angular-base';
+import { StackedColumnsDirective } from './stacked-column.directive';
+import * as i0 from "@angular/core";
+let input = ['allowEditing', 'allowFiltering', 'allowReordering', 'allowResizing', 'allowSorting', 'clipMode', 'columns', 'commands', 'customAttributes', 'defaultValue', 'disableHtmlEncode', 'displayAsCheckBox', 'edit', 'editTemplate', 'editType', 'field', 'filter', 'filterBarTemplate', 'filterTemplate', 'format', 'formatter', 'freeze', 'headerTemplate', 'headerText', 'headerTextAlign', 'hideAtMedia', 'isFrozen', 'isIdentity', 'isPrimaryKey', 'lockColumn', 'maxWidth', 'minWidth', 'showCheckbox', 'showColumnMenu', 'showInColumnChooser', 'sortComparer', 'template', 'textAlign', 'type', 'uid', 'validationRules', 'valueAccessor', 'visible', 'width'];
+let outputs = [];
+/**
+ * `e-column` directive represent a column of the Angular TreeGrid.
+ * It must be contained in a TreeGrid component(`ejs-treegrid`).
+ * ```html
+ * <ejs-treegrid [dataSource]='data' allowPaging='true' allowSorting='true'>
+ *   <e-columns>
+ *    <e-column field='ID' width='100'></e-column>
+ *    <e-column field='name' headerText='Name' width='100'></e-column>
+ *   </e-columns>
+ * </ejs-treegrid>
+ * ```
+ */
+export class ColumnDirective extends ComplexBase {
+    constructor(viewContainerRef) {
+        super();
+        this.viewContainerRef = viewContainerRef;
+        this.tags = ['columns'];
+        setValue('currentInstance', this, this.viewContainerRef);
+        this.registerEvents(outputs);
+        this.directivePropList = input;
+    }
+}
+ColumnDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: ColumnDirective, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+ColumnDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.3", type: ColumnDirective, selector: "ejs-treegrid>e-columns>e-column", inputs: { allowEditing: "allowEditing", allowFiltering: "allowFiltering", allowReordering: "allowReordering", allowResizing: "allowResizing", allowSorting: "allowSorting", clipMode: "clipMode", columns: "columns", commands: "commands", customAttributes: "customAttributes", defaultValue: "defaultValue", disableHtmlEncode: "disableHtmlEncode", displayAsCheckBox: "displayAsCheckBox", edit: "edit", editTemplate: "editTemplate", editType: "editType", field: "field", filter: "filter", filterBarTemplate: "filterBarTemplate", filterTemplate: "filterTemplate", format: "format", formatter: "formatter", freeze: "freeze", headerTemplate: "headerTemplate", headerText: "headerText", headerTextAlign: "headerTextAlign", hideAtMedia: "hideAtMedia", isFrozen: "isFrozen", isIdentity: "isIdentity", isPrimaryKey: "isPrimaryKey", lockColumn: "lockColumn", maxWidth: "maxWidth", minWidth: "minWidth", showCheckbox: "showCheckbox", showColumnMenu: "showColumnMenu", showInColumnChooser: "showInColumnChooser", sortComparer: "sortComparer", template: "template", textAlign: "textAlign", type: "type", uid: "uid", validationRules: "validationRules", valueAccessor: "valueAccessor", visible: "visible", width: "width" }, queries: [{ propertyName: "template", first: true, predicate: ["template"], descendants: true }, { propertyName: "headerTemplate", first: true, predicate: ["headerTemplate"], descendants: true }, { propertyName: "filter_itemTemplate", first: true, predicate: ["filterItemTemplate"], descendants: true }, { propertyName: "filterTemplate", first: true, predicate: ["filterTemplate"], descendants: true }, { propertyName: "commandsTemplate", first: true, predicate: ["commandsTemplate"], descendants: true }, { propertyName: "editTemplate", first: true, predicate: ["editTemplate"], descendants: true }, { propertyName: "childColumns", first: true, predicate: StackedColumnsDirective, descendants: true }], usesInheritance: true, ngImport: i0 });
+__decorate([
+    Template()
+], ColumnDirective.prototype, "template", void 0);
+__decorate([
+    Template()
+], ColumnDirective.prototype, "headerTemplate", void 0);
+__decorate([
+    Template()
+], ColumnDirective.prototype, "filter_itemTemplate", void 0);
+__decorate([
+    Template()
+], ColumnDirective.prototype, "filterTemplate", void 0);
+__decorate([
+    Template()
+], ColumnDirective.prototype, "commandsTemplate", void 0);
+__decorate([
+    Template()
+], ColumnDirective.prototype, "editTemplate", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: ColumnDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ejs-treegrid>e-columns>e-column',
+                    inputs: input,
+                    outputs: outputs,
+                    queries: {
+                        childColumns: new ContentChild(StackedColumnsDirective)
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }]; }, propDecorators: { template: [{
+                type: ContentChild,
+                args: ['template']
+            }], headerTemplate: [{
+                type: ContentChild,
+                args: ['headerTemplate']
+            }], filter_itemTemplate: [{
+                type: ContentChild,
+                args: ['filterItemTemplate']
+            }], filterTemplate: [{
+                type: ContentChild,
+                args: ['filterTemplate']
+            }], commandsTemplate: [{
+                type: ContentChild,
+                args: ['commandsTemplate']
+            }], editTemplate: [{
+                type: ContentChild,
+                args: ['editTemplate']
+            }] } });
+/**
+ * Column Array Directive
+ * @private
+ */
+export class ColumnsDirective extends ArrayBase {
+    constructor() {
+        super('columns');
+    }
+}
+ColumnsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: ColumnsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ColumnsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.3", type: ColumnsDirective, selector: "ejs-treegrid>e-columns", queries: [{ propertyName: "children", predicate: ColumnDirective }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: ColumnsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ejs-treegrid>e-columns',
+                    queries: {
+                        children: new ContentChildren(ColumnDirective)
+                    },
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"columns.directive.js","sourceRoot":"","sources":["../../../../src/treegrid/columns.directive.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAoB,eAAe,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC3F,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAChF,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AACxD,OAAO,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;;AAErE,IAAI,KAAK,GAAa,CAAC,cAAc,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,kBAAkB,EAAE,cAAc,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,EAAE,cAAc,EAAE,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,gBAAgB,EAAE,YAAY,EAAE,iBAAiB,EAAE,aAAa,EAAE,UAAU,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,cAAc,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,cAAc,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;AACxpB,IAAI,OAAO,GAAa,EAAE,CAAC;AAC3B;;;;;;;;;;;GAWG;AASH,MAAM,OAAO,eAAgB,SAAQ,WAA4B;IAyT7D,YAAoB,gBAAiC;QACjD,KAAK,EAAE,CAAC;QADQ,qBAAgB,GAAhB,gBAAgB,CAAiB;QArT9C,SAAI,GAAa,CAAC,SAAS,CAAC,CAAC;QAuThC,QAAQ,CAAC,iBAAiB,EAAE,IAAI,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;QACzD,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAC7B,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;IACnC,CAAC;;4GA9TQ,eAAe;gGAAf,eAAe,s3DAHW,uBAAuB;AA8R1D;IADC,QAAQ,EAAE;iDACU;AAQrB;IADC,QAAQ,EAAE;uDACgB;AAG3B;IADC,QAAQ,EAAE;4DACqB;AAOhC;IADC,QAAQ,EAAE;uDACgB;AAG3B;IADC,QAAQ,EAAE;yDACkB;AAO7B;IADC,QAAQ,EAAE;qDACc;2FAvThB,eAAe;kBAR3B,SAAS;mBAAC;oBACP,QAAQ,EAAE,iCAAiC;oBAC3C,MAAM,EAAE,KAAK;oBACb,OAAO,EAAE,OAAO;oBAChB,OAAO,EAAE;wBACL,YAAY,EAAE,IAAI,YAAY,CAAC,uBAAuB,CAAC;qBAC1D;iBACJ;uGA4RU,QAAQ;sBAFd,YAAY;uBAAC,UAAU;gBAUjB,cAAc;sBAFpB,YAAY;uBAAC,gBAAgB;gBAKvB,mBAAmB;sBAFzB,YAAY;uBAAC,oBAAoB;gBAS3B,cAAc;sBAFpB,YAAY;uBAAC,gBAAgB;gBAKvB,gBAAgB;sBAFtB,YAAY;uBAAC,kBAAkB;gBASzB,YAAY;sBAFlB,YAAY;uBAAC,cAAc;;AAYhC;;;GAGG;AAOH,MAAM,OAAO,gBAAiB,SAAQ,SAA2B;IAC7D;QACI,KAAK,CAAC,SAAS,CAAC,CAAC;IACrB,CAAC;;6GAHQ,gBAAgB;iGAAhB,gBAAgB,uFAHS,eAAe;2FAGxC,gBAAgB;kBAN5B,SAAS;mBAAC;oBACP,QAAQ,EAAE,wBAAwB;oBAClC,OAAO,EAAE;wBACL,QAAQ,EAAE,IAAI,eAAe,CAAC,eAAe,CAAC;qBACjD;iBACJ","sourcesContent":["import { Directive, ViewContainerRef, ContentChildren, ContentChild } from '@angular/core';\nimport { ComplexBase, ArrayBase, setValue } from '@syncfusion/ej2-angular-base';\nimport { Template } from '@syncfusion/ej2-angular-base';\nimport { StackedColumnsDirective } from './stacked-column.directive';\n\nlet input: string[] = ['allowEditing', 'allowFiltering', 'allowReordering', 'allowResizing', 'allowSorting', 'clipMode', 'columns', 'commands', 'customAttributes', 'defaultValue', 'disableHtmlEncode', 'displayAsCheckBox', 'edit', 'editTemplate', 'editType', 'field', 'filter', 'filterBarTemplate', 'filterTemplate', 'format', 'formatter', 'freeze', 'headerTemplate', 'headerText', 'headerTextAlign', 'hideAtMedia', 'isFrozen', 'isIdentity', 'isPrimaryKey', 'lockColumn', 'maxWidth', 'minWidth', 'showCheckbox', 'showColumnMenu', 'showInColumnChooser', 'sortComparer', 'template', 'textAlign', 'type', 'uid', 'validationRules', 'valueAccessor', 'visible', 'width'];\nlet outputs: string[] = [];\n/**\n * `e-column` directive represent a column of the Angular TreeGrid. \n * It must be contained in a TreeGrid component(`ejs-treegrid`). \n * ```html\n * <ejs-treegrid [dataSource]='data' allowPaging='true' allowSorting='true'> \n *   <e-columns>\n *    <e-column field='ID' width='100'></e-column>\n *    <e-column field='name' headerText='Name' width='100'></e-column>\n *   </e-columns>\n * </ejs-treegrid>\n * ```\n */\n@Directive({\n    selector: 'ejs-treegrid>e-columns>e-column',\n    inputs: input,\n    outputs: outputs,    \n    queries: {\n        childColumns: new ContentChild(StackedColumnsDirective)\n    }\n})\nexport class ColumnDirective extends ComplexBase<ColumnDirective> {\n    public directivePropList: any;\n\t\n    public childColumns: any;\n    public tags: string[] = ['columns'];\n    /** \n     * Defines the type of data stored in the column, which may be string, number, date, or other types.\n     * @default null\n     */\n    public type: any;\n    /** \n     * Controls whether editing is permitted for the column. By default, all columns are editable.\n     * @default true\n     */\n    public allowEditing: any;\n    /** \n     * Controls whether the column supports filtering. If set to false, users cannot filter data by this column.\n     * @default true\n     */\n    public allowFiltering: any;\n    /** \n     * Enables or disables the reordering of this column via drag-and-drop. Allows for dynamic column adjustments.\n     * @default true\n     */\n    public allowReordering: any;\n    /** \n     * Determines if this column can be resized. If false, the column size is fixed.\n     * @default true\n     */\n    public allowResizing: any;\n    /** \n     * Specifies whether sorting is enabled for this column. Set to false to prevent sort actions.\n     * @default true\n     */\n    public allowSorting: any;\n    /** \n     * Determines how overflow content is handled within a cell. Options include: \n     * * `Clip`: Truncates the content. \n     * * `Ellipsis`: Shows ellipsis for overflow. \n     * * `EllipsisWithTooltip`: Shows ellipsis and tooltip on hover.\n     * @default Syncfusion.EJ2.Grids.ClipMode.Ellipsis\n     * @isenumeration true\n     * @asptype Syncfusion.EJ2.Grids.ClipMode\n     */\n    public clipMode: any;\n    /** \n     * Allows for the creation of stacked headers by using multiple rows in the grid's header.\n     * @default null\n     */\n    public columns: any;\n    /** \n     * Provides built-in command button options for cells. Options include Edit, Delete, Save, and Cancel. \n     * Custom command button implementations are possible.\n     * \n     * The following code example implements the custom command column.\n     *```html\n     *<style type=\"text/css\" class=\"cssStyles\">\n     *.details-icon:before\n     *{\n     *   content:\"\\e74d\";\n     *}\n     *</style>\n     *<div id=\"TreeGrid\"></div>\n     *```\n     *```typescript\n     *var gridObj = new TreeGrid({\n     *datasource: window.gridData,\n     *columns : [\n     * { field: 'CustomerID', headerText: 'Customer ID' },\n     * { field: 'CustomerName', headerText: 'Customer Name' },\n     * {commands: [{buttonOption:{content: 'Details', click: onClick, cssClass: details-icon}}], headerText: 'Customer Details'}\n     *]\n     *gridObj.appendTo(\"#TreeGrid\");\n     *```\n     *     \n     * @default null\n     */\n    public commands: any;\n    /** \n     * Enables the addition of CSS styles and attributes for the content cells in a particular column.\n     * @default null\n     */\n    public customAttributes: any;\n    /** \n     * Sets default values when new records are added to the TreeGrid involving this column.\n     * @default null\n     */\n    public defaultValue: any;\n    /** \n     * If set to `true`, the HTML content within header and content cells is encoded to prevent injection attacks.\n     * @default true\n     */\n    public disableHtmlEncode: any;\n    /** \n     * Displays the column value as a checkbox instead of a Boolean value when set to `true`.\n     * @default false\n     */\n    public displayAsCheckBox: any;\n    /** \n     * Allows customizing the default edit cell through the `IEditCell` object for more control over editing.\n     * @default {}\n     */\n    public edit: any;\n    /** \n     * Specifies the component type used for editing cells within this column.\n     * @default 'stringedit'\n     */\n    public editType: any;\n    /** \n     * Specifies the field name in the data source to which the column is bound. This field is used for operations like sorting and filtering. \n     * The field name must be a valid JavaScript identifier, beginning with a letter and avoiding spaces and special characters.\n     * @default 'undefined'\n     */\n    public field: any;\n    /** \n     * Customizes filter options for the column, enabling specialized filtering functionality.\n     * @default null\n     */\n    public filter: any;\n    /** \n     * Allows for a custom component within the filter bar, facilitating advanced filter interfaces. \n     * Includes create and read functions for custom component management.\n     * \n     * ```html\n     *<div id=\"TreeGrid\"></div>\n     *```\n     *```typescript\n     *let gridObj: TreeGrid = new TreeGrid({\n     *dataSource: filterData,\n     *columns: [\n     *  { field: 'OrderID', headerText: 'Order ID' },\n     *  {\n     *     field: 'EmployeeID', filterBarTemplate: {\n     *        create: (args: { element: Element, column: Column }) => {\n     *             let input: HTMLInputElement = document.createElement('input');\n     *             input.id = 'EmployeeID';\n     *             input.type = 'text';\n     *             return input;\n     *        },\n     *        write: (args: { element: Element, column: Column }) => {\n     *            args.element.addEventListener('input', args.column.filterBarTemplate.read as EventListener);\n     *        },\n     *        read: (args: { element: HTMLInputElement, columnIndex: number, column: Column }) => {\n     *            gridObj.filterByColumn(args.element.id, 'equal', args.element.value);\n     *       }\n     *    }\n     *}],\n     *  allowFiltering: true\n     *});\n     *gridObj.appendTo('#TreeGrid');\n     *```\n     *     \n     * @default null\n     */\n    public filterBarTemplate: any;\n    /** \n     * Formats the displayed value of the column without affecting the underlying data. Supports standard and custom formats for numbers and dates.\n     * \n     * References for [number](https://ej2.syncfusion.com/documentation/common/internationalization/#supported-format-string)\n     *and [date](https://ej2.syncfusion.com/documentation/common/internationalization#date-formatting) formats.     \n     * @default null\n     * @asptype string\n     */\n    public format: any;\n    /** \n     * Allows for custom cell content formatting using an external method, executed prior to rendering.\n     * @default null\n     */\n    public formatter: any;\n    /** \n     * Determines which side (left, right, or center) the column should be frozen on.\n     * @default Syncfusion.EJ2.Grids.FreezeDirection.None\n     * @isenumeration true\n     * @asptype Syncfusion.EJ2.Grids.FreezeDirection\n     */\n    public freeze: any;\n    /** \n     * Specifies the text displayed in the column header. If omitted, the `field` value is used as the header text.\n     * @default 'undefined'\n     */\n    public headerText: any;\n    /** \n     * Aligns the text in the column header. By default, the alignment corresponds to other content alignments.\n     * @default null\n     * @aspdefaultvalueignore \n     * @isenumeration true\n     * @asptype Syncfusion.EJ2.Grids.TextAlign\n     */\n    public headerTextAlign: any;\n    /** \n     * Adjusts column visibility based on [Media Queries](http://cssmediaqueries.com/what-are-css-media-queries.html). Accepts valid CSS media query strings for responsive adjustments.\n     * @default 'undefined'\n     */\n    public hideAtMedia: any;\n    /** \n     * Allows the column to be frozen, keeping it stationary while scrolling horizontally through the grid.\n     * @default false\n     */\n    public isFrozen: any;\n    /** \n     * Identifies the column as an identity column in database terms, if set to `true`.\n     * @default false\n     */\n    public isIdentity: any;\n    /** \n     * Identifies the column as a primary key if set to `true`, enforcing uniqueness.\n     * @default false\n     */\n    public isPrimaryKey: any;\n    /** \n     * Prevents column reordering when set to true, locking the column into a set position.\n     * @default false\n     */\n    public lockColumn: any;\n    /** \n     * Defines the maximum allowable width of the column in pixels or as a percentage, preventing resizing beyond this limit.\n     * @default 'undefined'\n     */\n    public maxWidth: any;\n    /** \n     * Determines the minimum width of the column in pixels or percentage. This ensures the column does not shrink below this size.\n     * @default 'undefined'\n     */\n    public minWidth: any;\n    /** \n     * Displays checkboxes in the column when enabled, allowing for selections and certain operations.\n     * @default false\n     */\n    public showCheckbox: any;\n    /** \n     * Decides if the column menu should be available, providing options for column customization.\n     * @default true\n     */\n    public showColumnMenu: any;\n    /** \n     * Determines whether the column should appear in the Column Chooser. Set to false to exclude it.\n     * @default true\n     */\n    public showInColumnChooser: any;\n    /** \n     * Provides a custom sort comparer property to control how sorting is handled for this column's data.\n     * @default 'undefined'\n     */\n    public sortComparer: any;\n    /** \n     * Specifies the horizontal alignment for the column content and header. Options include alignment to the left, center, or right.\n     * @default Syncfusion.EJ2.Grids.TextAlign.Left\n     * @isenumeration true\n     * @asptype Syncfusion.EJ2.Grids.TextAlign\n     */\n    public textAlign: any;\n    /** \n     * Retrieves the unique identifier for the column. This UID is used internally to reference and manipulate the column.\n     * @default 'undefined'\n     */\n    public uid: any;\n    /** \n     * Establishes validation rules to ensure data integrity during creation and updates.\n     * @default null\n     */\n    public validationRules: any;\n    /** \n     * Applies custom cell values using an external function, allowing for dynamic display adjustments.\n     * @default null\n     */\n    public valueAccessor: any;\n    /** \n     * Toggles the visibility of the column. Set to false to hide the column from view. Columns are visible by default.\n     * @default true\n     */\n    public visible: any;\n    /** \n     * Sets the column's width in pixels or as a percentage. This defines how the column will occupy space in the grid.\n     * @default 'undefined'\n     */\n    public width: any;\n    /** \n     * Customizes the rendering of cell content using either a template string or HTML element ID.\n     * @default null\n     * @asptype string\n     */\n    @ContentChild('template')\n    @Template()\n    public template: any;\n    /** \n     * Customizes the header content with a template, defined as a string or an HTML element ID.\n     * @default null\n     * @asptype string\n     */\n    @ContentChild('headerTemplate')\n    @Template()\n    public headerTemplate: any;\n    @ContentChild('filterItemTemplate')\n    @Template()\n    public filter_itemTemplate: any;\n    /** \n     * Specifies a custom template or UI for filtering within this column, utilizing either string templates or HTML element IDs.\n     * @aspignore \n     */\n    @ContentChild('filterTemplate')\n    @Template()\n    public filterTemplate: any;\n    @ContentChild('commandsTemplate')\n    @Template()\n    public commandsTemplate: any;\n    /** \n     * Provides a template for editing cells in this column, supporting either a template string or an HTML element ID.\n     * @aspignore \n     */\n    @ContentChild('editTemplate')\n    @Template()\n    public editTemplate: any;\n\n    constructor(private viewContainerRef:ViewContainerRef) {\n        super();\n        setValue('currentInstance', this, this.viewContainerRef);\n        this.registerEvents(outputs);\n        this.directivePropList = input;\n    }\n}\n\n/**\n * Column Array Directive\n * @private\n */\n@Directive({\n    selector: 'ejs-treegrid>e-columns',\n    queries: {\n        children: new ContentChildren(ColumnDirective)\n    },\n})\nexport class ColumnsDirective extends ArrayBase<ColumnsDirective> {\n    constructor() {\n        super('columns');\n    }\n}"]}