@syncfusion/ej2-treegrid 30.2.4 → 31.1.17

package/dist/ts/treegrid/actions/excel-export.d.ts

@@ -0,0 +1,67 @@
+import { TreeGrid } from '../base/treegrid';
+import { ExcelExportProperties } from '@syncfusion/ej2-grids';
+import { Fetch } from '@syncfusion/ej2-base';
+import { Query } from '@syncfusion/ej2-data';
+/**
+ * TreeGrid Excel Export module
+ *
+ * @hidden
+ */
+export declare class ExcelExport {
+    private parent;
+    private dataResults;
+    private isCollapsedStatePersist;
+    /**
+     * Constructor for Excel Export module
+     *
+     * @param {TreeGrid} parent - Tree Grid instance
+     */
+    constructor(parent?: TreeGrid);
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @private
+     * @returns {string} Returns ExcelExport module name
+     */
+    protected getModuleName(): string;
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    addEventListener(): void;
+    /**
+     * To destroy the Excel Export
+     *
+     * @returns {void}
+     * @hidden
+     */
+    destroy(): void;
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    removeEventListener(): void;
+    private updateExcelResultModel;
+    Map(excelExportProperties?: ExcelExportProperties, isMultipleExport?: boolean, workbook?: any, isBlob?: boolean, isCsv?: boolean): Promise<Object>;
+    protected generateQuery(query: Query, property?: ExcelExportProperties): Query;
+    protected manipulateExportProperties(property?: ExcelExportProperties, dtSrc?: Object, queryResult?: Fetch): Object;
+    /**
+     * TreeGrid Excel Export cell modifier
+     *
+     * @param {ExcelQueryCellInfoEventArgs} args - current cell details
+     * @hidden
+     * @returns {void}
+     */
+    private excelQueryCellInfo;
+    /**
+     * TreeGrid Excel Export Aggregate cell modifier
+     *
+     * @param {AggregateQueryCellInfoEventArgs} args - current cell details
+     * @hidden
+     * @returns {void}
+     */
+    private excelAggregateCellInfo;
+    private exportRowDataBound;
+    private finalPageSetup;
+    private isLocal;
+}

package/dist/ts/treegrid/actions/excel-export.ts

@@ -0,0 +1,240 @@
+import { TreeGrid } from '../base/treegrid';
+import { ITreeData, TreeGridExcelExportProperties } from '../base/interface';
+import { getObject, Grid, ExcelExport as GridExcel, ExcelExportProperties, BeforeDataBoundArgs, ExportHelper } from '@syncfusion/ej2-grids';
+import { ExcelStyle, ExcelQueryCellInfoEventArgs, AggregateQueryCellInfoEventArgs } from '@syncfusion/ej2-grids';
+import { ExcelRow, Row, Column, Data } from '@syncfusion/ej2-grids';
+import { isRemoteData, isOffline, getParentData, getExpandStatus } from '../utils';
+import { isNullOrUndefined, setValue, Fetch, extend } from '@syncfusion/ej2-base';
+import { DataManager, Query, ReturnOption } from '@syncfusion/ej2-data';
+import * as event from '../base/constant';
+/**
+ * TreeGrid Excel Export module
+ *
+ * @hidden
+ */
+export class ExcelExport {
+    private parent: TreeGrid;
+    private dataResults: ReturnOption;
+    private isCollapsedStatePersist: boolean = false;
+    /**
+     * Constructor for Excel Export module
+     *
+     * @param {TreeGrid} parent - Tree Grid instance
+     */
+    constructor(parent?: TreeGrid) {
+        Grid.Inject(GridExcel);
+        this.parent = parent;
+        this.dataResults = <ReturnOption>{};
+        this.addEventListener();
+    }
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @private
+     * @returns {string} Returns ExcelExport module name
+     */
+    protected getModuleName(): string {
+        return 'ExcelExport';
+    }
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    public addEventListener(): void {
+        this.parent.on('updateResults', this.updateExcelResultModel, this);
+        this.parent.on('excelCellInfo', this.excelQueryCellInfo, this);
+        this.parent.grid.on('export-RowDataBound', this.exportRowDataBound, this);
+        this.parent.on('excelAggregateCellInfo', this.excelAggregateCellInfo, this);
+        this.parent.grid.on('finalPageSetup', this.finalPageSetup, this);
+    }
+    /**
+     * To destroy the Excel Export
+     *
+     * @returns {void}
+     * @hidden
+     */
+    public destroy(): void {
+        this.removeEventListener();
+    }
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    public removeEventListener(): void {
+        if (this.parent.isDestroyed) { return; }
+        this.parent.off('updateResults', this.updateExcelResultModel);
+        this.parent.off('excelCellInfo', this.excelQueryCellInfo);
+        this.parent.grid.off('export-RowDataBound', this.exportRowDataBound);
+        this.parent.off('excelAggregateCellInfo', this.excelAggregateCellInfo);
+        this.parent.grid.off('finalPageSetup', this.finalPageSetup);
+    }
+    private updateExcelResultModel(returnResult: { result: ITreeData[], count: number }): void {
+        this.dataResults = <ReturnOption>returnResult;
+    }
+    public Map(
+        excelExportProperties?: ExcelExportProperties,
+        /* eslint-disable-next-line */
+        isMultipleExport?: boolean, workbook?: any, isBlob?: boolean, isCsv?: boolean) : Promise<Object> {
+        const dataSource: object = this.parent.dataSource;
+        const data:  Data = new Data(this.parent.grid);
+        const property: Object = Object();
+        setValue('isCsv', isCsv, property);
+        setValue('cancel', false, property);
+        if (!isNullOrUndefined(excelExportProperties)) {
+            this.isCollapsedStatePersist = (excelExportProperties as TreeGridExcelExportProperties).isCollapsedStatePersist;
+        }
+        if (!isNullOrUndefined(excelExportProperties)) {
+            if (!this.isLocal() && !isNullOrUndefined(excelExportProperties.dataSource) && !excelExportProperties.dataSource['dataSource']) {
+                return this.parent.grid.excelExportModule.Map(
+                    this.parent.grid, excelExportProperties, isMultipleExport, workbook, isCsv, isBlob);
+            }
+            if (excelExportProperties.exportType === 'CurrentPage') {
+                excelExportProperties.dataSource = this.parent.getCurrentViewRecords();
+                return this.parent.grid.excelExportModule.Map(
+                    this.parent.grid, excelExportProperties, isMultipleExport, workbook, isCsv, isBlob);
+            }
+        }
+        return new Promise((resolve: Function) => {
+            const dm: DataManager = this.isLocal() && !(dataSource instanceof DataManager) ? new DataManager(dataSource)
+                : <DataManager>this.parent.dataSource;
+            let query: Query = new Query();
+            if (!this.isLocal()) {
+                query = this.generateQuery(query);
+                query.queries = this.parent.grid.getDataModule().generateQuery().queries;
+                query = ExportHelper.getQuery(this.parent.grid, data);
+                if (isNullOrUndefined(this.parent.filterModule)) {
+                    query.queries = query.queries.slice(1, 2);
+                    query.params = query.params.slice(0, 0);
+                }
+                setValue('query', query, property);
+            }
+            this.parent.trigger(event.beforeExcelExport, extend(property, excelExportProperties));
+            if (getObject('cancel', property)) {
+                return null;
+            }
+            dm.executeQuery(query).then((e: Object) => {
+                let customData: Object = null;
+                if (!isNullOrUndefined(excelExportProperties) && !isNullOrUndefined(excelExportProperties.dataSource)) {
+                    customData = excelExportProperties.dataSource;
+                }
+                excelExportProperties = this.manipulateExportProperties(excelExportProperties, dataSource, <Fetch>e);
+                return this.parent.grid.excelExportModule.Map(
+                    this.parent.grid, excelExportProperties, isMultipleExport, workbook, isCsv, isBlob).then((book: Object) => {
+                    if (customData != null) {
+                        excelExportProperties.dataSource = customData;
+                    } else {
+                        delete excelExportProperties.dataSource;
+                    }
+                    resolve(book);
+                });
+            });
+        });
+    }
+    protected generateQuery(query: Query, property?: ExcelExportProperties) : Query {
+        if (!isNullOrUndefined(property) && property.exportType === 'CurrentPage'
+        && this.parent.allowPaging) {
+            property.exportType = 'AllPages';
+            query.addParams('ExportType', 'CurrentPage');
+            query.where(this.parent.parentIdMapping, 'equal', null);
+            query = getObject('grid.renderModule.data.pageQuery', this.parent)(query);
+        }
+        return query;
+    }
+    protected manipulateExportProperties(property?: ExcelExportProperties, dtSrc?: Object, queryResult?: Fetch) : Object {
+        //count not required for this query
+        let args: BeforeDataBoundArgs = Object();
+        if (!isNullOrUndefined(this.parent.grid.getDataModule())) {
+            setValue('query', this.parent.grid.getDataModule().generateQuery(true), args);
+        }
+        setValue('isExport',  true, args);
+        if (!isNullOrUndefined(property) && !isNullOrUndefined(property.exportType)) {
+            setValue('exportType',  property.exportType, args);
+        }
+        if (!this.isLocal()) {
+            this.parent.parentData = [];
+            this.parent.dataModule.convertToFlatData(getObject('result', queryResult));
+            setValue('expresults',  this.parent.flatData, args);
+        }
+        this.parent.notify('dataProcessor', args);
+        //args = this.parent.dataModule.dataProcessor(args);
+        args = <BeforeDataBoundArgs>this.dataResults;
+        dtSrc = isNullOrUndefined(args.result) ? this.parent.flatData.slice(0) : args.result;
+        if (!this.isLocal()) {
+            this.parent.flatData = [];
+        }
+        if (property && property.dataSource) {
+            const flatsData: Object[] = this.parent.flatData;
+            const dataSrc: Object = property.dataSource instanceof DataManager ? property.dataSource.dataSource.json : property.dataSource;
+            this.parent.dataModule.convertToFlatData(dataSrc);
+            dtSrc = this.parent.flatData;
+            this.parent.flatData = flatsData;
+        }
+        property = isNullOrUndefined(property) ? Object() : property;
+        property.dataSource = new DataManager({json: <Object[]>dtSrc});
+        if (this.parent.aggregates.length > 0) {
+            property.query = args['query'];
+        }
+        return property;
+    }
+    /**
+     * TreeGrid Excel Export cell modifier
+     *
+     * @param {ExcelQueryCellInfoEventArgs} args - current cell details
+     * @hidden
+     * @returns {void}
+     */
+    private excelQueryCellInfo(args?: ExcelQueryCellInfoEventArgs) : void {
+        if (this.parent.grid.getColumnIndexByUid(args.column.uid) === this.parent.treeColumnIndex) {
+            const style: ExcelStyle = {};
+            const data: ITreeData = <ITreeData>args.data;
+            const ispadfilter: boolean = isNullOrUndefined(data.filterLevel);
+            const pad: number = ispadfilter ? data.level : data.filterLevel;
+            style.indent = pad;
+            args.style = style;
+        }
+        this.parent.notify('updateResults', args);
+        this.parent.trigger('excelQueryCellInfo', args);
+    }
+    /**
+     * TreeGrid Excel Export Aggregate cell modifier
+     *
+     * @param {AggregateQueryCellInfoEventArgs} args - current cell details
+     * @hidden
+     * @returns {void}
+     */
+    private excelAggregateCellInfo(args?: AggregateQueryCellInfoEventArgs) : void {
+        this.parent.trigger('excelAggregateQueryCellInfo', args);
+    }
+    private exportRowDataBound(excelRow: {excelRows: ExcelRow[], rowObj: Row<Column>, type: string}) : void {
+        if (excelRow.type === 'excel') {
+            const excelrowobj: ITreeData = excelRow.rowObj.data;
+            const filtercolumnlength: number = this.parent.grid.filterSettings.columns.length;
+            const rowlength: number = excelRow.excelRows.length;
+            const rowlevel: number = excelrowobj.level;
+            if (excelrowobj.parentItem && getParentData(this.parent, excelrowobj.parentItem.uniqueID, Boolean(filtercolumnlength))) {
+                let expandedStatus: boolean = false; let sublevelState: boolean = false;
+                const state: boolean = getExpandStatus(this.parent, excelrowobj, this.parent.parentData);
+                if (this.isCollapsedStatePersist && (!state || !this.parent.isLocalData)) {
+                    expandedStatus = true;
+                    sublevelState = excelrowobj.expanded ? false : true;
+                }
+                excelRow.excelRows[rowlength - 1].grouping = { outlineLevel: rowlevel, isCollapsed: sublevelState,
+                    isHidden: expandedStatus };
+            }
+            else if (excelrowobj.hasChildRecords && isNullOrUndefined(excelrowobj.parentItem)) {
+                excelRow.excelRows[rowlength - 1].grouping = { outlineLevel: rowlevel};
+            }
+        }
+    }
+    /* eslint-disable-next-line */
+      private finalPageSetup(workbook: any): void {
+        for (let i: number = 0; i < workbook.worksheets.length; i++) {
+            if (workbook.worksheets[parseInt(i.toString(), 10)].rows) {
+                workbook.worksheets[parseInt(i.toString(), 10)].pageSetup = { isSummaryRowBelow: false };
+            }
+        }
+    }
+    private isLocal(): boolean {
+        return !isRemoteData(this.parent) && isOffline(this.parent);
+    }
+}

package/dist/ts/treegrid/actions/filter.d.ts

@@ -0,0 +1,57 @@
+import { TreeGrid } from '../base/treegrid';
+/**
+ * TreeGrid Filter module will handle filtering action
+ *
+ * @hidden
+ */
+export declare class Filter {
+    private parent;
+    filteredResult: Object[];
+    private flatFilteredData;
+    private filteredParentRecs;
+    private isHierarchyFilter;
+    /**
+     * Constructor for Filter module
+     *
+     * @param {TreeGrid} parent - Tree Grid instance
+     */
+    constructor(parent?: TreeGrid);
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @private
+     * @returns {string} Returns Filter module name
+     */
+    protected getModuleName(): string;
+    /**
+     * To destroy the Filter module
+     *
+     * @returns {void}
+     * @hidden
+     */
+    destroy(): void;
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    addEventListener(): void;
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    removeEventListener(): void;
+    /**
+     * Function to update filtered records
+     *
+     * @param {{data: Object} } dataDetails - Filtered data collection
+     * @param {Object} dataDetails.data - Fliltered data collection
+     * @hidden
+     * @returns {void}
+     */
+    private updatedFilteredRecord;
+    private updateParentFilteredRecord;
+    private addParentRecord;
+    private checkChildExsist;
+    private updateFilterLevel;
+    private clearFilterLevel;
+}

package/dist/ts/treegrid/actions/filter.ts

@@ -0,0 +1,231 @@
+import { TreeGrid } from '../base/treegrid';
+import { getObject, Filter as GridFilter, Grid } from '@syncfusion/ej2-grids';
+import { isNullOrUndefined, setValue, getValue } from '@syncfusion/ej2-base';
+import { ITreeData } from '../base';
+import { getParentData } from '../utils';
+import {  FilterHierarchyMode } from '..';
+
+/**
+ * TreeGrid Filter module will handle filtering action
+ *
+ * @hidden
+ */
+export class Filter {
+
+    private parent: TreeGrid;
+    public filteredResult: Object[];
+    private flatFilteredData: Object[];
+    private filteredParentRecs: Object[];
+    private isHierarchyFilter: boolean;
+    /**
+     * Constructor for Filter module
+     *
+     * @param {TreeGrid} parent - Tree Grid instance
+     */
+    constructor(parent?: TreeGrid) {
+        Grid.Inject(GridFilter);
+        this.parent = parent;
+        this.isHierarchyFilter = false;
+        this.filteredResult = [];
+        this.flatFilteredData = [];
+        this.filteredParentRecs = [];
+        this.addEventListener();
+    }
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @private
+     * @returns {string} Returns Filter module name
+     */
+    protected getModuleName(): string {
+        return 'filter';
+    }
+    /**
+     * To destroy the Filter module
+     *
+     * @returns {void}
+     * @hidden
+     */
+    public destroy(): void {
+        this.removeEventListener();
+    }
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    public addEventListener(): void {
+        this.parent.on('updateFilterRecs', this.updatedFilteredRecord, this);
+        this.parent.on('clearFilters', this.clearFilterLevel, this);
+    }
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    public removeEventListener(): void {
+        if (this.parent.isDestroyed) { return; }
+        this.parent.off('updateFilterRecs', this.updatedFilteredRecord);
+        this.parent.off('clearFilters', this.clearFilterLevel);
+    }
+    /**
+     * Function to update filtered records
+     *
+     * @param {{data: Object} } dataDetails - Filtered data collection
+     * @param {Object} dataDetails.data - Fliltered data collection
+     * @hidden
+     * @returns {void}
+     */
+    private updatedFilteredRecord(dataDetails: { data: Object }): void {
+        setValue('uniqueIDFilterCollection', {}, this.parent);
+        this.flatFilteredData = dataDetails.data as Object[];
+        this.filteredParentRecs = [];
+        this.filteredResult = [];
+        this.isHierarchyFilter = false;
+        const hierarchyMode: FilterHierarchyMode = this.parent.grid.searchSettings.key === '' ? this.parent.filterSettings.hierarchyMode
+            : this.parent.searchSettings.hierarchyMode;
+        for (let f: number = 0; f < this.flatFilteredData.length; f++) {
+            const rec: ITreeData = this.flatFilteredData[parseInt(f.toString(), 10)];
+            this.addParentRecord(rec);
+            if (((hierarchyMode === 'Child' || hierarchyMode === 'None') &&
+            (this.parent.grid.filterSettings.columns.length !== 0 || this.parent.grid.searchSettings.key !== ''))) {
+                this.isHierarchyFilter = true;
+            }
+            const ischild: Object[] = getObject('childRecords', rec);
+            if (!isNullOrUndefined(ischild) && ischild.length) {
+                setValue('hasFilteredChildRecords', this.checkChildExsist(rec), rec);
+            }
+            const parent: Object = getObject('parentItem', rec);
+            if (!isNullOrUndefined(parent)) {
+                const parRecord: ITreeData = getParentData(this.parent, rec.parentItem.uniqueID, true);
+                setValue('hasFilteredChildRecords', true, parRecord);
+                if (parRecord && parRecord.parentItem) {
+                    this.updateParentFilteredRecord(parRecord);
+                }
+            }
+        }
+        if (this.flatFilteredData.length > 0 && this.isHierarchyFilter) {
+            this.updateFilterLevel();
+        }
+        this.parent.notify('updateAction', { result: this.filteredResult });
+    }
+    private updateParentFilteredRecord(record: ITreeData): void {
+        const parRecord: ITreeData = getParentData(this.parent, record.parentItem.uniqueID, true);
+        const uniqueIDValue: Object = getValue('uniqueIDFilterCollection', this.parent);
+        if (parRecord && Object.prototype.hasOwnProperty.call(uniqueIDValue, parRecord.uniqueID)) {
+            setValue('hasFilteredChildRecords', true, parRecord);
+        }
+        if (parRecord && parRecord.parentItem) {
+            this.updateParentFilteredRecord(parRecord);
+        }
+    }
+    private addParentRecord(record: ITreeData): void {
+        const parent: Object = getParentData(this.parent, record.parentUniqueID);
+        const hierarchyMode: FilterHierarchyMode = this.parent.grid.searchSettings.key === '' ? this.parent.filterSettings.hierarchyMode
+            : this.parent.searchSettings.hierarchyMode;
+        if (hierarchyMode === 'None' && (this.parent.grid.filterSettings.columns.length !== 0
+            || this.parent.grid.searchSettings.key !== '')) {
+            if (isNullOrUndefined(parent)) {
+                if (this.flatFilteredData.indexOf(record) !== -1) {
+                    if (this.filteredResult.indexOf(record) === -1) {
+                        this.filteredResult.push(record);
+                        setValue('uniqueIDFilterCollection.' + record.uniqueID, record, this.parent);
+                        record.hasFilteredChildRecords = true;
+                    }
+                    return;
+                }
+            } else {
+                this.addParentRecord(parent);
+                if (this.flatFilteredData.indexOf(parent) !== -1 || this.filteredResult.indexOf(parent) !== -1) {
+                    if (this.filteredResult.indexOf(record) === -1) {
+                        this.filteredResult.push(record);
+                        setValue('uniqueIDFilterCollection.' + record.uniqueID, record, this.parent);
+                    }
+                } else {
+                    if (this.filteredResult.indexOf(record) === -1 && this.flatFilteredData.indexOf(record) !== -1) {
+                        this.filteredResult.push(record);
+                        setValue('uniqueIDFilterCollection.' + record.uniqueID, record, this.parent);
+                    }
+                }
+            }
+        } else {
+            if (!isNullOrUndefined(parent)) {
+                const hierarchyMode: FilterHierarchyMode = this.parent.grid.searchSettings.key === '' ?
+                    this.parent.filterSettings.hierarchyMode : this.parent.searchSettings.hierarchyMode;
+                if (hierarchyMode === 'Child' && (this.parent.grid.filterSettings.columns.length !== 0
+                    || this.parent.grid.searchSettings.key !== '')) {
+                    if (this.flatFilteredData.indexOf(parent) !== -1) {
+                        this.addParentRecord(parent);
+                    }
+                } else {
+                    this.addParentRecord(parent);
+                }
+            }
+            if (this.filteredResult.indexOf(record) === -1) {
+                this.filteredResult.push(record);
+                setValue('uniqueIDFilterCollection.' + record.uniqueID, record, this.parent);
+            }
+        }
+    }
+    private checkChildExsist(records: Object): boolean {
+        const childRec: ITreeData[] = getObject('childRecords', records);
+        let isExist: boolean = false;
+        for (let count: number = 0; count < childRec.length; count++) {
+            const ischild: Object[] = childRec[parseInt(count.toString(), 10)].childRecords;
+            const hierarchyMode: FilterHierarchyMode = this.parent.grid.searchSettings.key === '' ?
+                this.parent.filterSettings.hierarchyMode : this.parent.searchSettings.hierarchyMode;
+            if (((hierarchyMode === 'Child' || hierarchyMode === 'Both') && (this.parent.grid.filterSettings.columns.length !== 0
+                || this.parent.grid.searchSettings.key !== ''))) {
+                const uniqueIDValue: Object = getValue('uniqueIDFilterCollection', this.parent);
+                if (!Object.prototype.hasOwnProperty.call(uniqueIDValue, childRec[parseInt(count.toString(), 10)].uniqueID)) {
+                    this.filteredResult.push(childRec[parseInt(count.toString(), 10)]);
+                    setValue('uniqueIDFilterCollection.' + childRec[parseInt(count.toString(), 10)].uniqueID, childRec[parseInt(count.toString(), 10)], this.parent);
+                    isExist = true;
+                }
+            }
+            if ((hierarchyMode === 'None')
+                && (this.parent.grid.filterSettings.columns.length !== 0 || this.parent.grid.searchSettings.key !== '')) {
+                if (this.flatFilteredData.indexOf(childRec[parseInt(count.toString(), 10)]) !== -1) {
+                    isExist = true;
+                    break;
+                }
+            }
+            if (!isNullOrUndefined(ischild) && ischild.length) {
+                isExist = this.checkChildExsist(childRec[parseInt(count.toString(), 10)]);
+            }
+            if ((hierarchyMode === 'Child' || hierarchyMode === 'Both') && childRec.length) {
+                isExist = true;
+            }
+        }
+        return isExist;
+    }
+    private  updateFilterLevel(): void {
+        const record: ITreeData[] = this.filteredResult;
+        const len: number = this.filteredResult.length;
+        for (let c: number = 0; c < len; c++) {
+            const parent: ITreeData =  getParentData(this.parent, record[parseInt(c.toString(), 10)].parentUniqueID);
+            const isPrst: boolean = record.indexOf(parent) !== -1;
+            if (isPrst) {
+                const parent: ITreeData = getParentData(this.parent, record[parseInt(c.toString(), 10)].parentUniqueID, true);
+                record[parseInt(c.toString(), 10)].filterLevel = parent.filterLevel + 1;
+            } else {
+                record[parseInt(c.toString(), 10)].filterLevel = 0;
+                this.filteredParentRecs.push(record[parseInt(c.toString(), 10)]);
+            }
+        }
+    }
+    private clearFilterLevel(data: { flatData: Object[] }): void {
+        let count: number = 0;
+        const flatData: ITreeData[] = data.flatData as ITreeData[];
+        const len: number = flatData.length;
+        let currentRecord: ITreeData;
+        for (count; count < len; count++) {
+            currentRecord = flatData[parseInt(count.toString(), 10)];
+            const fLevel: number = currentRecord.filterLevel;
+            if (fLevel || fLevel === 0 || !isNullOrUndefined(currentRecord.hasFilteredChildRecords)) {
+                currentRecord.hasFilteredChildRecords = null;
+                currentRecord.filterLevel = null;
+            }
+        }
+        this.filteredResult = [];
+        this.parent.notify('updateResults', { result: flatData, count: flatData.length });
+    }
+}

package/dist/ts/treegrid/actions/freeze-column.d.ts

@@ -0,0 +1,28 @@
+import { TreeGrid } from '../base/treegrid';
+/**
+ * TreeGrid Freeze module
+ *
+ * @hidden
+ */
+export declare class Freeze {
+    private parent;
+    /**
+     * Constructor for render module
+     *
+     * @param {TreeGrid} parent - Tree Grid instance
+     */
+    constructor(parent?: TreeGrid);
+    addEventListener(): void;
+    removeEventListener(): void;
+    private rowExpandCollapse;
+    private dblClickHandler;
+    private dataBoundArg;
+    destroy(): void;
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @private
+     * @returns {string} Returns Freeze module name
+     */
+    private getModuleName;
+}