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

package/esm2020/src/treegrid/stacked-column.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 * as i0 from "@angular/core";
+let input = ['allowEditing', 'allowFiltering', 'allowReordering', 'allowResizing', 'allowSorting', 'clipMode', 'columns', 'commands', 'customAttributes', 'defaultValue', 'disableHtmlEncode', 'displayAsCheckBox', 'edit', 'editTemplate', 'editType', 'enableColumnSpan', 'enableRowSpan', '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-stacked-column` directive represent the stacked column of the Angular TreeGrid.
+ * It must be contained in a StackedColumns component(`e-stacked-columns`).
+ * ```html
+ * <ejs-treegrid [dataSource]='data' allowPaging='true' allowSorting='true'>
+ *   <e-columns>
+ *     <e-column field='ID' width='100'></e-column>
+ *     <e-column headerText='Details' width='100'>
+ *       <e-stacked-columns>
+ *         <e-stacked-column field='Name' width='140'></e-stacked-column>
+ *       </e-stacked-columns>
+ *     </e-column>
+ *   </e-columns>
+ * </ejs-treegrid>
+ * ```
+ */
+export class StackedColumnDirective extends ComplexBase {
+    constructor(viewContainerRef) {
+        super();
+        this.viewContainerRef = viewContainerRef;
+        setValue('currentInstance', this, this.viewContainerRef);
+        this.registerEvents(outputs);
+        this.directivePropList = input;
+    }
+}
+StackedColumnDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: StackedColumnDirective, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+StackedColumnDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.3", type: StackedColumnDirective, selector: "ejs-treegrid>e-columns>e-column>e-stacked-columns>e-stacked-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", enableColumnSpan: "enableColumnSpan", enableRowSpan: "enableRowSpan", 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 }], usesInheritance: true, ngImport: i0 });
+__decorate([
+    Template()
+], StackedColumnDirective.prototype, "template", void 0);
+__decorate([
+    Template()
+], StackedColumnDirective.prototype, "headerTemplate", void 0);
+__decorate([
+    Template()
+], StackedColumnDirective.prototype, "filter_itemTemplate", void 0);
+__decorate([
+    Template()
+], StackedColumnDirective.prototype, "filterTemplate", void 0);
+__decorate([
+    Template()
+], StackedColumnDirective.prototype, "commandsTemplate", void 0);
+__decorate([
+    Template()
+], StackedColumnDirective.prototype, "editTemplate", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: StackedColumnDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ejs-treegrid>e-columns>e-column>e-stacked-columns>e-stacked-column',
+                    inputs: input,
+                    outputs: outputs,
+                    queries: {}
+                }]
+        }], 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']
+            }] } });
+/**
+ * StackedColumn Array Directive
+ * @private
+ */
+export class StackedColumnsDirective extends ArrayBase {
+    constructor() {
+        super('columns');
+    }
+}
+StackedColumnsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: StackedColumnsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+StackedColumnsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.3", type: StackedColumnsDirective, selector: "ejs-treegrid>e-columns>e-column>e-stacked-columns", queries: [{ propertyName: "children", predicate: StackedColumnDirective }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: StackedColumnsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ejs-treegrid>e-columns>e-column>e-stacked-columns',
+                    queries: {
+                        children: new ContentChildren(StackedColumnDirective)
+                    },
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stacked-column.directive.js","sourceRoot":"","sources":["../../../../src/treegrid/stacked-column.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;;AAGxD,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,kBAAkB,EAAE,eAAe,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;AAC7rB,IAAI,OAAO,GAAa,EAAE,CAAC;AAC3B;;;;;;;;;;;;;;;GAeG;AASH,MAAM,OAAO,sBAAuB,SAAQ,WAAmC;IAmU3E,YAAoB,gBAAiC;QACjD,KAAK,EAAE,CAAC;QADQ,qBAAgB,GAAhB,gBAAgB,CAAiB;QAEjD,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;;mHAxUQ,sBAAsB;uGAAtB,sBAAsB;AAqS/B;IADC,QAAQ,EAAE;wDACU;AAQrB;IADC,QAAQ,EAAE;8DACgB;AAG3B;IADC,QAAQ,EAAE;mEACqB;AAOhC;IADC,QAAQ,EAAE;8DACgB;AAG3B;IADC,QAAQ,EAAE;gEACkB;AAO7B;IADC,QAAQ,EAAE;4DACc;2FAjUhB,sBAAsB;kBARlC,SAAS;mBAAC;oBACP,QAAQ,EAAE,oEAAoE;oBAC9E,MAAM,EAAE,KAAK;oBACb,OAAO,EAAE,OAAO;oBAChB,OAAO,EAAE,EAER;iBACJ;uGAsSU,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,uBAAwB,SAAQ,SAAkC;IAC3E;QACI,KAAK,CAAC,SAAS,CAAC,CAAC;IACrB,CAAC;;oHAHQ,uBAAuB;wGAAvB,uBAAuB,kHAHE,sBAAsB;2FAG/C,uBAAuB;kBANnC,SAAS;mBAAC;oBACP,QAAQ,EAAE,mDAAmD;oBAC7D,OAAO,EAAE;wBACL,QAAQ,EAAE,IAAI,eAAe,CAAC,sBAAsB,CAAC;qBACxD;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';\n\n\nlet input: string[] = ['allowEditing', 'allowFiltering', 'allowReordering', 'allowResizing', 'allowSorting', 'clipMode', 'columns', 'commands', 'customAttributes', 'defaultValue', 'disableHtmlEncode', 'displayAsCheckBox', 'edit', 'editTemplate', 'editType', 'enableColumnSpan', 'enableRowSpan', '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-stacked-column` directive represent the stacked column of the Angular TreeGrid.\n * It must be contained in a StackedColumns component(`e-stacked-columns`). \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 headerText='Details' width='100'>\n *       <e-stacked-columns>\n *         <e-stacked-column field='Name' width='140'></e-stacked-column>\n *       </e-stacked-columns>\n *     </e-column>\n *   </e-columns>\n * </ejs-treegrid>\n * ```\n */\n@Directive({\n    selector: 'ejs-treegrid>e-columns>e-column>e-stacked-columns>e-stacked-column',\n    inputs: input,\n    outputs: outputs,    \n    queries: {\n\n    }\n})\nexport class StackedColumnDirective extends ComplexBase<StackedColumnDirective> {\n    public directivePropList: any;\n\t\n\n\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     * Allows treegrid to perform column spanning on the specified column.\n     * @default true\n     */\n    public enableColumnSpan: any;\n    /** \n     * Allows treegrid to perform row spanning on the specified column.\n     * @default true\n     */\n    public enableRowSpan: 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 * StackedColumn Array Directive\n * @private\n */\n@Directive({\n    selector: 'ejs-treegrid>e-columns>e-column>e-stacked-columns',\n    queries: {\n        children: new ContentChildren(StackedColumnDirective)\n    },\n})\nexport class StackedColumnsDirective extends ArrayBase<StackedColumnsDirective> {\n    constructor() {\n        super('columns');\n    }\n}"]}

package/esm2020/src/treegrid/treegrid-all.module.mjs

@@ -0,0 +1,89 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { TreeGridModule } from './treegrid.module';
+import { Filter, Page, Sort, Reorder, Toolbar, Aggregate, Resize, ColumnMenu, ExcelExport, PdfExport, CommandColumn, ContextMenu, Edit, Selection, VirtualScroll, DetailRow, RowDD, Freeze, ColumnChooser, Logger, InfiniteScroll } from '@syncfusion/ej2-treegrid';
+import * as i0 from "@angular/core";
+export const FilterService = { provide: 'TreeGridFilter', useValue: Filter };
+export const PageService = { provide: 'TreeGridPage', useValue: Page };
+export const SortService = { provide: 'TreeGridSort', useValue: Sort };
+export const ReorderService = { provide: 'TreeGridReorder', useValue: Reorder };
+export const ToolbarService = { provide: 'TreeGridToolbar', useValue: Toolbar };
+export const AggregateService = { provide: 'TreeGridAggregate', useValue: Aggregate };
+export const ResizeService = { provide: 'TreeGridResize', useValue: Resize };
+export const ColumnMenuService = { provide: 'TreeGridColumnMenu', useValue: ColumnMenu };
+export const ExcelExportService = { provide: 'TreeGridExcelExport', useValue: ExcelExport };
+export const PdfExportService = { provide: 'TreeGridPdfExport', useValue: PdfExport };
+export const CommandColumnService = { provide: 'TreeGridCommandColumn', useValue: CommandColumn };
+export const ContextMenuService = { provide: 'TreeGridContextMenu', useValue: ContextMenu };
+export const EditService = { provide: 'TreeGridEdit', useValue: Edit };
+export const SelectionService = { provide: 'TreeGridSelection', useValue: Selection };
+export const VirtualScrollService = { provide: 'TreeGridVirtualScroll', useValue: VirtualScroll };
+export const DetailRowService = { provide: 'TreeGridDetailRow', useValue: DetailRow };
+export const RowDDService = { provide: 'TreeGridRowDD', useValue: RowDD };
+export const FreezeService = { provide: 'TreeGridFreeze', useValue: Freeze };
+export const ColumnChooserService = { provide: 'TreeGridColumnChooser', useValue: ColumnChooser };
+export const LoggerService = { provide: 'TreeGridLogger', useValue: Logger };
+export const InfiniteScrollService = { provide: 'TreeGridInfiniteScroll', useValue: InfiniteScroll };
+/**
+ * NgModule definition for the TreeGrid component with providers.
+ */
+export class TreeGridAllModule {
+}
+TreeGridAllModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TreeGridAllModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TreeGridAllModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TreeGridAllModule, imports: [CommonModule, TreeGridModule], exports: [TreeGridModule] });
+TreeGridAllModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TreeGridAllModule, providers: [
+        FilterService,
+        PageService,
+        SortService,
+        ReorderService,
+        ToolbarService,
+        AggregateService,
+        ResizeService,
+        ColumnMenuService,
+        ExcelExportService,
+        PdfExportService,
+        CommandColumnService,
+        ContextMenuService,
+        EditService,
+        SelectionService,
+        VirtualScrollService,
+        DetailRowService,
+        RowDDService,
+        FreezeService,
+        ColumnChooserService,
+        LoggerService,
+        InfiniteScrollService
+    ], imports: [[CommonModule, TreeGridModule], TreeGridModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TreeGridAllModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, TreeGridModule],
+                    exports: [
+                        TreeGridModule
+                    ],
+                    providers: [
+                        FilterService,
+                        PageService,
+                        SortService,
+                        ReorderService,
+                        ToolbarService,
+                        AggregateService,
+                        ResizeService,
+                        ColumnMenuService,
+                        ExcelExportService,
+                        PdfExportService,
+                        CommandColumnService,
+                        ContextMenuService,
+                        EditService,
+                        SelectionService,
+                        VirtualScrollService,
+                        DetailRowService,
+                        RowDDService,
+                        FreezeService,
+                        ColumnChooserService,
+                        LoggerService,
+                        InfiniteScrollService
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"treegrid-all.module.js","sourceRoot":"","sources":["../../../../src/treegrid/treegrid-all.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgModule, ValueProvider } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { StackedColumnDirective, StackedColumnsDirective } from './stacked-column.directive';\nimport { ColumnDirective, ColumnsDirective } from './columns.directive';\nimport { AggregateColumnDirective, AggregateColumnsDirective } from './aggregate-columns.directive';\nimport { AggregateDirective, AggregatesDirective } from './aggregates.directive';\nimport { TreeGridComponent } from './treegrid.component';\nimport { TreeGridModule } from './treegrid.module';\nimport {Filter, Page, Sort, Reorder, Toolbar, Aggregate, Resize, ColumnMenu, ExcelExport, PdfExport, CommandColumn, ContextMenu, Edit, Selection, VirtualScroll, DetailRow, RowDD, Freeze, ColumnChooser, Logger, InfiniteScroll} from '@syncfusion/ej2-treegrid'\n\n\nexport const FilterService: ValueProvider = { provide: 'TreeGridFilter', useValue: Filter};\nexport const PageService: ValueProvider = { provide: 'TreeGridPage', useValue: Page};\nexport const SortService: ValueProvider = { provide: 'TreeGridSort', useValue: Sort};\nexport const ReorderService: ValueProvider = { provide: 'TreeGridReorder', useValue: Reorder};\nexport const ToolbarService: ValueProvider = { provide: 'TreeGridToolbar', useValue: Toolbar};\nexport const AggregateService: ValueProvider = { provide: 'TreeGridAggregate', useValue: Aggregate};\nexport const ResizeService: ValueProvider = { provide: 'TreeGridResize', useValue: Resize};\nexport const ColumnMenuService: ValueProvider = { provide: 'TreeGridColumnMenu', useValue: ColumnMenu};\nexport const ExcelExportService: ValueProvider = { provide: 'TreeGridExcelExport', useValue: ExcelExport};\nexport const PdfExportService: ValueProvider = { provide: 'TreeGridPdfExport', useValue: PdfExport};\nexport const CommandColumnService: ValueProvider = { provide: 'TreeGridCommandColumn', useValue: CommandColumn};\nexport const ContextMenuService: ValueProvider = { provide: 'TreeGridContextMenu', useValue: ContextMenu};\nexport const EditService: ValueProvider = { provide: 'TreeGridEdit', useValue: Edit};\nexport const SelectionService: ValueProvider = { provide: 'TreeGridSelection', useValue: Selection};\nexport const VirtualScrollService: ValueProvider = { provide: 'TreeGridVirtualScroll', useValue: VirtualScroll};\nexport const DetailRowService: ValueProvider = { provide: 'TreeGridDetailRow', useValue: DetailRow};\nexport const RowDDService: ValueProvider = { provide: 'TreeGridRowDD', useValue: RowDD};\nexport const FreezeService: ValueProvider = { provide: 'TreeGridFreeze', useValue: Freeze};\nexport const ColumnChooserService: ValueProvider = { provide: 'TreeGridColumnChooser', useValue: ColumnChooser};\nexport const LoggerService: ValueProvider = { provide: 'TreeGridLogger', useValue: Logger};\nexport const InfiniteScrollService: ValueProvider = { provide: 'TreeGridInfiniteScroll', useValue: InfiniteScroll};\n\n/**\n * NgModule definition for the TreeGrid component with providers.\n */\n@NgModule({\n    imports: [CommonModule, TreeGridModule],\n    exports: [\n        TreeGridModule\n    ],\n    providers:[\n        FilterService,\n        PageService,\n        SortService,\n        ReorderService,\n        ToolbarService,\n        AggregateService,\n        ResizeService,\n        ColumnMenuService,\n        ExcelExportService,\n        PdfExportService,\n        CommandColumnService,\n        ContextMenuService,\n        EditService,\n        SelectionService,\n        VirtualScrollService,\n        DetailRowService,\n        RowDDService,\n        FreezeService,\n        ColumnChooserService,\n        LoggerService,\n        InfiniteScrollService\n    ]\n})\nexport class TreeGridAllModule { }"]}

package/esm2020/src/treegrid/treegrid.component.mjs

@@ -0,0 +1,271 @@
+import { __decorate } from "tslib";
+import { Component, ChangeDetectionStrategy, ContentChild } from '@angular/core';
+import { ComponentBase, ComponentMixins, setValue } from '@syncfusion/ej2-angular-base';
+import { TreeGrid } from '@syncfusion/ej2-treegrid';
+import { Template } from '@syncfusion/ej2-angular-base';
+import { ColumnsDirective } from './columns.directive';
+import { AggregatesDirective } from './aggregates.directive';
+import * as i0 from "@angular/core";
+export const inputs = ['aggregates', 'allowExcelExport', 'allowFiltering', 'allowMultiSorting', 'allowPaging', 'allowPdfExport', 'allowReordering', 'allowResizing', 'allowRowDragAndDrop', 'allowSelection', 'allowSorting', 'allowTextWrap', 'autoCheckHierarchy', 'childMapping', 'clipMode', 'columnChooserSettings', 'columnMenuItems', 'columnQueryMode', 'columns', 'contextMenuItems', 'copyHierarchyMode', 'currencyCode', 'dataSource', 'detailTemplate', 'editSettings', 'emptyRecordTemplate', 'enableAdaptiveUI', 'enableAltRow', 'enableAutoFill', 'enableCollapseAll', 'enableColumnSpan', 'enableColumnVirtualization', 'enableHover', 'enableHtmlSanitizer', 'enableImmutableMode', 'enableInfiniteScrolling', 'enablePersistence', 'enableRowSpan', 'enableRtl', 'enableStickyHeader', 'enableVirtualMaskRow', 'enableVirtualization', 'expandStateMapping', 'filterSettings', 'frozenColumns', 'frozenRows', 'gridLines', 'hasChildMapping', 'height', 'idMapping', 'infiniteScrollSettings', 'isRowSelectable', 'loadChildOnDemand', 'loadingIndicator', 'locale', 'pageSettings', 'pagerTemplate', 'parentIdMapping', 'printMode', 'query', 'rowDropSettings', 'rowHeight', 'rowTemplate', 'searchSettings', 'selectedRowIndex', 'selectionSettings', 'showColumnChooser', 'showColumnMenu', 'sortSettings', 'textWrapSettings', 'toolbar', 'treeColumnIndex', 'width'];
+export const outputs = ['actionBegin', 'actionComplete', 'actionFailure', 'batchAdd', 'batchCancel', 'batchDelete', 'beforeBatchAdd', 'beforeBatchDelete', 'beforeBatchSave', 'beforeCopy', 'beforeDataBound', 'beforeExcelExport', 'beforePaste', 'beforePdfExport', 'beforePrint', 'beginEdit', 'cellDeselected', 'cellDeselecting', 'cellEdit', 'cellSave', 'cellSaved', 'cellSelected', 'cellSelecting', 'checkboxChange', 'collapsed', 'collapsing', 'columnDrag', 'columnDragStart', 'columnDrop', 'columnMenuClick', 'columnMenuOpen', 'contextMenuClick', 'contextMenuOpen', 'created', 'dataBound', 'dataSourceChanged', 'dataStateChange', 'detailDataBound', 'excelAggregateQueryCellInfo', 'excelExportComplete', 'excelHeaderQueryCellInfo', 'excelQueryCellInfo', 'expanded', 'expanding', 'headerCellInfo', 'load', 'pdfAggregateQueryCellInfo', 'pdfExportComplete', 'pdfHeaderQueryCellInfo', 'pdfQueryCellInfo', 'printComplete', 'queryCellInfo', 'recordDoubleClick', 'resizeStart', 'resizeStop', 'resizing', 'rowDataBound', 'rowDeselected', 'rowDeselecting', 'rowDrag', 'rowDragStart', 'rowDragStartHelper', 'rowDrop', 'rowSelected', 'rowSelecting', 'toolbarClick', 'dataSourceChange'];
+export const twoWays = ['dataSource'];
+/**
+ * `ejs-treegrid` represents the Angular TreeTreeGrid Component.
+ * ```html
+ * <ejs-treegrid [dataSource]='data' allowPaging='true' allowSorting='true'></ejs-treegrid>
+ * ```
+ */
+let TreeGridComponent = class TreeGridComponent extends TreeGrid {
+    constructor(ngEle, srenderer, viewContainerRef, injector) {
+        super();
+        this.ngEle = ngEle;
+        this.srenderer = srenderer;
+        this.viewContainerRef = viewContainerRef;
+        this.injector = injector;
+        this.tags = ['columns', 'aggregates'];
+        this.element = this.ngEle.nativeElement;
+        this.injectedModules = this.injectedModules || [];
+        try {
+            let mod = this.injector.get('TreeGridFilter');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridPage');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridSort');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridReorder');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridToolbar');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridAggregate');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridResize');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridColumnMenu');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridExcelExport');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridPdfExport');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridCommandColumn');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridContextMenu');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridEdit');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridSelection');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridVirtualScroll');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridDetailRow');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridRowDD');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridFreeze');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridColumnChooser');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridLogger');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        try {
+            let mod = this.injector.get('TreeGridInfiniteScroll');
+            if (this.injectedModules.indexOf(mod) === -1) {
+                this.injectedModules.push(mod);
+            }
+        }
+        catch { }
+        this.registerEvents(outputs);
+        this.addTwoWay.call(this, twoWays);
+        setValue('currentInstance', this, this.viewContainerRef);
+        this.context = new ComponentBase();
+    }
+    ngOnInit() {
+        this.context.ngOnInit(this);
+    }
+    ngAfterViewInit() {
+        this.context.ngAfterViewInit(this);
+    }
+    ngOnDestroy() {
+        this.context.ngOnDestroy(this);
+    }
+    ngAfterContentChecked() {
+        this.tagObjects[0].instance = this.childColumns;
+        if (this.childAggregates) {
+            this.tagObjects[1].instance = this.childAggregates;
+        }
+        this.context.ngAfterContentChecked(this);
+    }
+};
+TreeGridComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TreeGridComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ViewContainerRef }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+TreeGridComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.3", type: TreeGridComponent, selector: "ejs-treegrid", inputs: { aggregates: "aggregates", allowExcelExport: "allowExcelExport", allowFiltering: "allowFiltering", allowMultiSorting: "allowMultiSorting", allowPaging: "allowPaging", allowPdfExport: "allowPdfExport", allowReordering: "allowReordering", allowResizing: "allowResizing", allowRowDragAndDrop: "allowRowDragAndDrop", allowSelection: "allowSelection", allowSorting: "allowSorting", allowTextWrap: "allowTextWrap", autoCheckHierarchy: "autoCheckHierarchy", childMapping: "childMapping", clipMode: "clipMode", columnChooserSettings: "columnChooserSettings", columnMenuItems: "columnMenuItems", columnQueryMode: "columnQueryMode", columns: "columns", contextMenuItems: "contextMenuItems", copyHierarchyMode: "copyHierarchyMode", currencyCode: "currencyCode", dataSource: "dataSource", detailTemplate: "detailTemplate", editSettings: "editSettings", emptyRecordTemplate: "emptyRecordTemplate", enableAdaptiveUI: "enableAdaptiveUI", enableAltRow: "enableAltRow", enableAutoFill: "enableAutoFill", enableCollapseAll: "enableCollapseAll", enableColumnSpan: "enableColumnSpan", enableColumnVirtualization: "enableColumnVirtualization", enableHover: "enableHover", enableHtmlSanitizer: "enableHtmlSanitizer", enableImmutableMode: "enableImmutableMode", enableInfiniteScrolling: "enableInfiniteScrolling", enablePersistence: "enablePersistence", enableRowSpan: "enableRowSpan", enableRtl: "enableRtl", enableStickyHeader: "enableStickyHeader", enableVirtualMaskRow: "enableVirtualMaskRow", enableVirtualization: "enableVirtualization", expandStateMapping: "expandStateMapping", filterSettings: "filterSettings", frozenColumns: "frozenColumns", frozenRows: "frozenRows", gridLines: "gridLines", hasChildMapping: "hasChildMapping", height: "height", idMapping: "idMapping", infiniteScrollSettings: "infiniteScrollSettings", isRowSelectable: "isRowSelectable", loadChildOnDemand: "loadChildOnDemand", loadingIndicator: "loadingIndicator", locale: "locale", pageSettings: "pageSettings", pagerTemplate: "pagerTemplate", parentIdMapping: "parentIdMapping", printMode: "printMode", query: "query", rowDropSettings: "rowDropSettings", rowHeight: "rowHeight", rowTemplate: "rowTemplate", searchSettings: "searchSettings", selectedRowIndex: "selectedRowIndex", selectionSettings: "selectionSettings", showColumnChooser: "showColumnChooser", showColumnMenu: "showColumnMenu", sortSettings: "sortSettings", textWrapSettings: "textWrapSettings", toolbar: "toolbar", treeColumnIndex: "treeColumnIndex", width: "width" }, outputs: { actionBegin: "actionBegin", actionComplete: "actionComplete", actionFailure: "actionFailure", batchAdd: "batchAdd", batchCancel: "batchCancel", batchDelete: "batchDelete", beforeBatchAdd: "beforeBatchAdd", beforeBatchDelete: "beforeBatchDelete", beforeBatchSave: "beforeBatchSave", beforeCopy: "beforeCopy", beforeDataBound: "beforeDataBound", beforeExcelExport: "beforeExcelExport", beforePaste: "beforePaste", beforePdfExport: "beforePdfExport", beforePrint: "beforePrint", beginEdit: "beginEdit", cellDeselected: "cellDeselected", cellDeselecting: "cellDeselecting", cellEdit: "cellEdit", cellSave: "cellSave", cellSaved: "cellSaved", cellSelected: "cellSelected", cellSelecting: "cellSelecting", checkboxChange: "checkboxChange", collapsed: "collapsed", collapsing: "collapsing", columnDrag: "columnDrag", columnDragStart: "columnDragStart", columnDrop: "columnDrop", columnMenuClick: "columnMenuClick", columnMenuOpen: "columnMenuOpen", contextMenuClick: "contextMenuClick", contextMenuOpen: "contextMenuOpen", created: "created", dataBound: "dataBound", dataSourceChanged: "dataSourceChanged", dataStateChange: "dataStateChange", detailDataBound: "detailDataBound", excelAggregateQueryCellInfo: "excelAggregateQueryCellInfo", excelExportComplete: "excelExportComplete", excelHeaderQueryCellInfo: "excelHeaderQueryCellInfo", excelQueryCellInfo: "excelQueryCellInfo", expanded: "expanded", expanding: "expanding", headerCellInfo: "headerCellInfo", load: "load", pdfAggregateQueryCellInfo: "pdfAggregateQueryCellInfo", pdfExportComplete: "pdfExportComplete", pdfHeaderQueryCellInfo: "pdfHeaderQueryCellInfo", pdfQueryCellInfo: "pdfQueryCellInfo", printComplete: "printComplete", queryCellInfo: "queryCellInfo", recordDoubleClick: "recordDoubleClick", resizeStart: "resizeStart", resizeStop: "resizeStop", resizing: "resizing", rowDataBound: "rowDataBound", rowDeselected: "rowDeselected", rowDeselecting: "rowDeselecting", rowDrag: "rowDrag", rowDragStart: "rowDragStart", rowDragStartHelper: "rowDragStartHelper", rowDrop: "rowDrop", rowSelected: "rowSelected", rowSelecting: "rowSelecting", toolbarClick: "toolbarClick", dataSourceChange: "dataSourceChange" }, queries: [{ propertyName: "toolbarTemplate", first: true, predicate: ["toolbarTemplate"], descendants: true }, { propertyName: "pagerTemplate", first: true, predicate: ["pagerTemplate"], descendants: true }, { propertyName: "rowTemplate", first: true, predicate: ["rowTemplate"], descendants: true }, { propertyName: "detailTemplate", first: true, predicate: ["detailTemplate"], descendants: true }, { propertyName: "editSettings_template", first: true, predicate: ["editSettingsTemplate"], descendants: true }, { propertyName: "emptyRecordTemplate", first: true, predicate: ["emptyRecordTemplate"], descendants: true }, { propertyName: "columnChooserSettings_headerTemplate", first: true, predicate: ["columnChooserSettingsHeaderTemplate"], descendants: true }, { propertyName: "columnChooserSettings_template", first: true, predicate: ["columnChooserSettingsTemplate"], descendants: true }, { propertyName: "columnChooserSettings_footerTemplate", first: true, predicate: ["columnChooserSettingsFooterTemplate"], descendants: true }, { propertyName: "childColumns", first: true, predicate: ColumnsDirective, descendants: true }, { propertyName: "childAggregates", first: true, predicate: AggregatesDirective, descendants: true }], usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+__decorate([
+    Template()
+], TreeGridComponent.prototype, "toolbarTemplate", void 0);
+__decorate([
+    Template()
+], TreeGridComponent.prototype, "pagerTemplate", void 0);
+__decorate([
+    Template()
+], TreeGridComponent.prototype, "rowTemplate", void 0);
+__decorate([
+    Template()
+], TreeGridComponent.prototype, "detailTemplate", void 0);
+__decorate([
+    Template()
+], TreeGridComponent.prototype, "editSettings_template", void 0);
+__decorate([
+    Template()
+], TreeGridComponent.prototype, "emptyRecordTemplate", void 0);
+__decorate([
+    Template()
+], TreeGridComponent.prototype, "columnChooserSettings_headerTemplate", void 0);
+__decorate([
+    Template()
+], TreeGridComponent.prototype, "columnChooserSettings_template", void 0);
+__decorate([
+    Template()
+], TreeGridComponent.prototype, "columnChooserSettings_footerTemplate", void 0);
+TreeGridComponent = __decorate([
+    ComponentMixins([ComponentBase])
+], TreeGridComponent);
+export { TreeGridComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TreeGridComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ejs-treegrid',
+                    inputs: inputs,
+                    outputs: outputs,
+                    template: '',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    queries: {
+                        childColumns: new ContentChild(ColumnsDirective),
+                        childAggregates: new ContentChild(AggregatesDirective)
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ViewContainerRef }, { type: i0.Injector }]; }, propDecorators: { toolbarTemplate: [{
+                type: ContentChild,
+                args: ['toolbarTemplate']
+            }], pagerTemplate: [{
+                type: ContentChild,
+                args: ['pagerTemplate']
+            }], rowTemplate: [{
+                type: ContentChild,
+                args: ['rowTemplate']
+            }], detailTemplate: [{
+                type: ContentChild,
+                args: ['detailTemplate']
+            }], editSettings_template: [{
+                type: ContentChild,
+                args: ['editSettingsTemplate']
+            }], emptyRecordTemplate: [{
+                type: ContentChild,
+                args: ['emptyRecordTemplate']
+            }], columnChooserSettings_headerTemplate: [{
+                type: ContentChild,
+                args: ['columnChooserSettingsHeaderTemplate']
+            }], columnChooserSettings_template: [{
+                type: ContentChild,
+                args: ['columnChooserSettingsTemplate']
+            }], columnChooserSettings_footerTemplate: [{
+                type: ContentChild,
+                args: ['columnChooserSettingsFooterTemplate']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"treegrid.component.js","sourceRoot":"","sources":["../../../../src/treegrid/treegrid.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, ViewContainerRef, ChangeDetectionStrategy, QueryList, Renderer2, Injector, ValueProvider, ContentChild } from '@angular/core';\nimport { ComponentBase, IComponentBase, applyMixins, ComponentMixins, PropertyCollectionInfo, setValue } from '@syncfusion/ej2-angular-base';\nimport { TreeGrid } from '@syncfusion/ej2-treegrid';\nimport { Template } from '@syncfusion/ej2-angular-base';\nimport { ColumnsDirective } from './columns.directive';\nimport { AggregatesDirective } from './aggregates.directive';\n\nexport const inputs: string[] = ['aggregates','allowExcelExport','allowFiltering','allowMultiSorting','allowPaging','allowPdfExport','allowReordering','allowResizing','allowRowDragAndDrop','allowSelection','allowSorting','allowTextWrap','autoCheckHierarchy','childMapping','clipMode','columnChooserSettings','columnMenuItems','columnQueryMode','columns','contextMenuItems','copyHierarchyMode','currencyCode','dataSource','detailTemplate','editSettings','emptyRecordTemplate','enableAdaptiveUI','enableAltRow','enableAutoFill','enableCollapseAll','enableColumnSpan','enableColumnVirtualization','enableHover','enableHtmlSanitizer','enableImmutableMode','enableInfiniteScrolling','enablePersistence','enableRowSpan','enableRtl','enableStickyHeader','enableVirtualMaskRow','enableVirtualization','expandStateMapping','filterSettings','frozenColumns','frozenRows','gridLines','hasChildMapping','height','idMapping','infiniteScrollSettings','isRowSelectable','loadChildOnDemand','loadingIndicator','locale','pageSettings','pagerTemplate','parentIdMapping','printMode','query','rowDropSettings','rowHeight','rowTemplate','searchSettings','selectedRowIndex','selectionSettings','showColumnChooser','showColumnMenu','sortSettings','textWrapSettings','toolbar','treeColumnIndex','width'];\nexport const outputs: string[] = ['actionBegin','actionComplete','actionFailure','batchAdd','batchCancel','batchDelete','beforeBatchAdd','beforeBatchDelete','beforeBatchSave','beforeCopy','beforeDataBound','beforeExcelExport','beforePaste','beforePdfExport','beforePrint','beginEdit','cellDeselected','cellDeselecting','cellEdit','cellSave','cellSaved','cellSelected','cellSelecting','checkboxChange','collapsed','collapsing','columnDrag','columnDragStart','columnDrop','columnMenuClick','columnMenuOpen','contextMenuClick','contextMenuOpen','created','dataBound','dataSourceChanged','dataStateChange','detailDataBound','excelAggregateQueryCellInfo','excelExportComplete','excelHeaderQueryCellInfo','excelQueryCellInfo','expanded','expanding','headerCellInfo','load','pdfAggregateQueryCellInfo','pdfExportComplete','pdfHeaderQueryCellInfo','pdfQueryCellInfo','printComplete','queryCellInfo','recordDoubleClick','resizeStart','resizeStop','resizing','rowDataBound','rowDeselected','rowDeselecting','rowDrag','rowDragStart','rowDragStartHelper','rowDrop','rowSelected','rowSelecting','toolbarClick','dataSourceChange'];\nexport const twoWays: string[] = ['dataSource'];\n\n/**\n * `ejs-treegrid` represents the Angular TreeTreeGrid Component.\n * ```html\n * <ejs-treegrid [dataSource]='data' allowPaging='true' allowSorting='true'></ejs-treegrid>\n * ```\n */\n@Component({\n    selector: 'ejs-treegrid',\n    inputs: inputs,\n    outputs: outputs,\n    template: '',\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    queries: {\n        childColumns: new ContentChild(ColumnsDirective), \n        childAggregates: new ContentChild(AggregatesDirective)\n    }\n})\n@ComponentMixins([ComponentBase])\nexport class TreeGridComponent extends TreeGrid implements IComponentBase {\n    public context : any;\n    public tagObjects: any;\n\tactionBegin: any;\n\tactionComplete: any;\n\tactionFailure: any;\n\tbatchAdd: any;\n\tbatchCancel: any;\n\tbatchDelete: any;\n\tbeforeBatchAdd: any;\n\tbeforeBatchDelete: any;\n\tbeforeBatchSave: any;\n\tbeforeCopy: any;\n\tbeforeDataBound: any;\n\tbeforeExcelExport: any;\n\tbeforePaste: any;\n\tbeforePdfExport: any;\n\tbeforePrint: any;\n\tbeginEdit: any;\n\tcellDeselected: any;\n\tcellDeselecting: any;\n\tcellEdit: any;\n\tcellSave: any;\n\tcellSaved: any;\n\tcellSelected: any;\n\tcellSelecting: any;\n\tcheckboxChange: any;\n\tcollapsed: any;\n\tcollapsing: any;\n\tcolumnDrag: any;\n\tcolumnDragStart: any;\n\tcolumnDrop: any;\n\tcolumnMenuClick: any;\n\tcolumnMenuOpen: any;\n\tcontextMenuClick: any;\n\tcontextMenuOpen: any;\n\tcreated: any;\n\tdataBound: any;\n\tdataSourceChanged: any;\n\tdataStateChange: any;\n\tdetailDataBound: any;\n\texcelAggregateQueryCellInfo: any;\n\texcelExportComplete: any;\n\texcelHeaderQueryCellInfo: any;\n\texcelQueryCellInfo: any;\n\texpanded: any;\n\texpanding: any;\n\theaderCellInfo: any;\n\tload: any;\n\tpdfAggregateQueryCellInfo: any;\n\tpdfExportComplete: any;\n\tpdfHeaderQueryCellInfo: any;\n\tpdfQueryCellInfo: any;\n\tprintComplete: any;\n\tqueryCellInfo: any;\n\trecordDoubleClick: any;\n\tresizeStart: any;\n\tresizeStop: any;\n\tresizing: any;\n\trowDataBound: any;\n\trowDeselected: any;\n\trowDeselecting: any;\n\trowDrag: any;\n\trowDragStart: any;\n\trowDragStartHelper: any;\n\trowDrop: any;\n\trowSelected: any;\n\trowSelecting: any;\n\ttoolbarClick: any;\n\tpublic dataSourceChange: any;\n    public childColumns: QueryList<ColumnsDirective>;\n    public childAggregates: QueryList<AggregatesDirective>;\n    public tags: string[] = ['columns', 'aggregates'];\n    @ContentChild('toolbarTemplate')\n    @Template()\n    public toolbarTemplate: any;\n    /** \n     * It used to render pager template\n     * @default null\n     * @asptype string\n     */\n    @ContentChild('pagerTemplate')\n    @Template()\n    public pagerTemplate: any;\n    /** \n     * The row template that renders customized rows from the given template. \n     * By default, TreeGrid renders a table row for every data source item. \n     * > * It accepts either [template string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) \n     * or HTML element ID. \n     * > * The row template must be a table row.\n     * \n     * > Check the [Row Template](../../treegrid/row) customization.\n     *     \n     * @asptype string\n     */\n    @ContentChild('rowTemplate')\n    @Template()\n    public rowTemplate: any;\n    /** \n     * The detail template allows you to show or hide additional information about a particular row.\n     * \n     * > It accepts either the [template string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals)\n     *or the HTML element ID.\n     *     \n     * @asptype string\n     */\n    @ContentChild('detailTemplate')\n    @Template()\n    public detailTemplate: any;\n    @ContentChild('editSettingsTemplate')\n    @Template()\n    public editSettings_template: any;\n    /** \n     * The empty record template that renders customized element or text or image instead of displaying the empty record message in the TreeGrid.\n     * \n     * > It accepts either the [template string](../../common/template-engine/) or the HTML element ID.\n     *     \n     * @default null\n     * @asptype string\n     */\n    @ContentChild('emptyRecordTemplate')\n    @Template()\n    public emptyRecordTemplate: any;\n    @ContentChild('columnChooserSettingsHeaderTemplate')\n    @Template()\n    public columnChooserSettings_headerTemplate: any;\n    @ContentChild('columnChooserSettingsTemplate')\n    @Template()\n    public columnChooserSettings_template: any;\n    @ContentChild('columnChooserSettingsFooterTemplate')\n    @Template()\n    public columnChooserSettings_footerTemplate: any;\n\n    constructor(private ngEle: ElementRef, private srenderer: Renderer2, private viewContainerRef:ViewContainerRef, private injector: Injector) {\n        super();\n        this.element = this.ngEle.nativeElement;\n        this.injectedModules = this.injectedModules || [];\n        try {\n                let mod = this.injector.get('TreeGridFilter');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridPage');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridSort');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridReorder');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridToolbar');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridAggregate');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridResize');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridColumnMenu');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridExcelExport');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridPdfExport');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridCommandColumn');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridContextMenu');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridEdit');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridSelection');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridVirtualScroll');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridDetailRow');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridRowDD');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridFreeze');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridColumnChooser');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridLogger');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r        try {\n                let mod = this.injector.get('TreeGridInfiniteScroll');\n                if(this.injectedModules.indexOf(mod) === -1) {\n                    this.injectedModules.push(mod)\n                }\n            } catch { }\n\r\n        this.registerEvents(outputs);\n        this.addTwoWay.call(this, twoWays);\n        setValue('currentInstance', this, this.viewContainerRef);\n        this.context  = new ComponentBase();\n    }\n\n    public ngOnInit() {\n        this.context.ngOnInit(this);\n    }\n\n    public ngAfterViewInit(): void {\n        this.context.ngAfterViewInit(this);\n    }\n\n    public ngOnDestroy(): void {\n        this.context.ngOnDestroy(this);\n    }\n\n    public ngAfterContentChecked(): void {\n        this.tagObjects[0].instance = this.childColumns;\n        if (this.childAggregates) {\n                    this.tagObjects[1].instance = this.childAggregates as any;\n                }\n        this.context.ngAfterContentChecked(this);\n    }\n\n    public registerEvents: (eventList: string[]) => void;\n    public addTwoWay: (propList: string[]) => void;\n}\n\n"]}