@syncfusion/ej2-treegrid 30.2.4 → 31.1.17

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

@@ -0,0 +1,51 @@
+import { TreeGrid } from '../base/treegrid';
+/**
+ * TreeGrid Selection module
+ *
+ * @hidden
+ */
+export declare class Selection {
+    private parent;
+    private columnIndex;
+    private selectedItems;
+    private selectedIndexes;
+    private filteredList;
+    private searchingRecords;
+    /**
+     * Constructor for Selection module
+     *
+     * @param {TreeGrid} parent - Tree Grid instance
+     */
+    constructor(parent: TreeGrid);
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @private
+     * @returns {string} Returns Selection module name
+     */
+    private getModuleName;
+    addEventListener(): void;
+    removeEventListener(): void;
+    /**
+     * To destroy the Selection
+     *
+     * @returns {void}
+     * @hidden
+     */
+    destroy(): void;
+    private checkboxSelection;
+    private triggerChkChangeEvent;
+    private getCheckboxcolumnIndex;
+    private headerCheckbox;
+    private renderColumnCheckbox;
+    private columnCheckbox;
+    selectCheckboxes(rowIndexes: number[]): void;
+    private traverSelection;
+    private getFilteredChildRecords;
+    private updateParentSelection;
+    private headerSelection;
+    private updateSelectedItems;
+    private updateGridActions;
+    getCheckedrecords(): Object[];
+    getCheckedRowIndexes(): number[];
+}

package/dist/ts/treegrid/actions/selection.ts

@@ -0,0 +1,530 @@
+import { TreeGrid } from '../base/treegrid';
+import { ColumnModel } from '../models/column';
+import { isNullOrUndefined, removeClass } from '@syncfusion/ej2-base';
+import { createCheckBox } from '@syncfusion/ej2-buttons';
+import { QueryCellInfoEventArgs, parentsUntil, getObject } from '@syncfusion/ej2-grids';
+import { CellSaveEventArgs } from '../base/interface';
+import { ITreeData } from '../base/interface';
+import * as events from '../base/constant';
+import { getParentData, isRemoteData, isCheckboxcolumn, findChildrenRecords } from '../utils';
+
+/**
+ * TreeGrid Selection module
+ *
+ * @hidden
+ */
+export class Selection {
+    private parent: TreeGrid;
+    private columnIndex: number;
+    private selectedItems: Object[];
+    private selectedIndexes: number[];
+    private filteredList: Object[];
+    private searchingRecords: Object[];
+    /**
+     * Constructor for Selection module
+     *
+     * @param {TreeGrid} parent - Tree Grid instance
+     */
+    constructor(parent: TreeGrid) {
+        this.parent = parent;
+        this.selectedItems = [];
+        this.selectedIndexes = [];
+        this.filteredList = [];
+        this.searchingRecords = [];
+        this.addEventListener();
+    }
+
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @private
+     * @returns {string} Returns Selection module name
+     */
+    private getModuleName(): string {
+        return 'selection';
+    }
+
+    public addEventListener(): void {
+        this.parent.on('dataBoundArg', this.headerCheckbox, this);
+        this.parent.on('columnCheckbox', this.columnCheckbox, this);
+        this.parent.on('updateGridActions', this.updateGridActions, this);
+        this.parent.grid.on('colgroup-refresh', this.headerCheckbox, this);
+        this.parent.on('checkboxSelection', this.checkboxSelection, this);
+
+    }
+
+    public removeEventListener(): void {
+        if (this.parent.isDestroyed) { return; }
+        this.parent.off('dataBoundArg', this.headerCheckbox);
+        this.parent.off('columnCheckbox', this.columnCheckbox);
+        this.parent.grid.off('colgroup-refresh', this.headerCheckbox);
+        this.parent.off('checkboxSelection', this.checkboxSelection);
+        this.parent.off('updateGridActions', this.updateGridActions);
+    }
+
+    /**
+     * To destroy the Selection
+     *
+     * @returns {void}
+     * @hidden
+     */
+    public destroy(): void {
+        this.removeEventListener();
+    }
+
+    private checkboxSelection(args: Object): void {
+        const target: HTMLElement = getObject('target', args);
+        const checkWrap: HTMLElement = parentsUntil(target, 'e-checkbox-wrapper') as HTMLElement;
+        let checkBox: HTMLInputElement;
+        if (checkWrap && checkWrap.querySelectorAll('.e-treecheckselect').length > 0) {
+            checkBox = checkWrap.querySelector('input[type="checkbox"]') as HTMLInputElement;
+            const rowIndex: number[] = [];
+            rowIndex.push((target.closest('tr') as HTMLTableRowElement).rowIndex);
+            this.selectCheckboxes(rowIndex);
+            this.triggerChkChangeEvent(checkBox, checkBox.nextElementSibling.classList.contains('e-check'), target.closest('tr'));
+        } else if (checkWrap && checkWrap.querySelectorAll('.e-treeselectall').length > 0 && this.parent.autoCheckHierarchy) {
+            const checkBoxvalue: boolean = !checkWrap.querySelector('.e-frame').classList.contains('e-check')
+        && !checkWrap.querySelector('.e-frame').classList.contains('e-stop');
+            this.headerSelection(checkBoxvalue);
+            checkBox = checkWrap.querySelector('input[type="checkbox"]') as HTMLInputElement;
+            this.triggerChkChangeEvent(checkBox, checkBoxvalue, target.closest('tr'));
+
+        }
+        if (!isNullOrUndefined(this.parent['parentQuery']) && this.parent.selectionSettings.persistSelection
+            && this.parent['columnModel'].filter((col: { type: string }) => { return col.type === 'checkbox'; }).length > 0
+            && isRemoteData(this.parent)) {
+            if (this.parent['parentQuery'].length > 0) {
+                this.parent.query.queries.push(...this.parent['parentQuery']);
+                this.parent['parentQuery'] = [];
+            }
+        }
+    }
+
+    private triggerChkChangeEvent(checkBox: HTMLInputElement, checkState: boolean, rowElement: HTMLTableRowElement): void {
+        const data: ITreeData = this.parent.getCurrentViewRecords()[rowElement.rowIndex];
+        const args: Object = { checked: checkState, target: checkBox, rowElement: rowElement,
+            rowData: checkBox.classList.contains('e-treeselectall')
+                ? this.parent.getCheckedRecords() : data };
+        this.parent.trigger(events.checkboxChange, args);
+    }
+
+    private getCheckboxcolumnIndex(): number {
+        let mappingUid: string; let columnIndex: number; const stackedHeader: string = 'stackedHeader';
+        const columnModel: string = 'columnModel';
+        const columns: ColumnModel[] = this.parent[`${stackedHeader}`] ? this.parent[`${columnModel}`] :  <ColumnModel[]>(this.parent.columns);
+        for (let col: number = 0; col < columns.length; col++) {
+            if ((<ColumnModel>columns[parseInt(col.toString(), 10)]).showCheckbox) {
+                mappingUid = (<ColumnModel>columns[parseInt(col.toString(), 10)]).uid;
+            }
+        }
+        const headerCelllength: number = this.parent.getHeaderContent().querySelectorAll('.e-headercelldiv').length;
+        for (let j: number = 0; j < headerCelllength; j++) {
+            const headercell: Element = this.parent.getHeaderContent().querySelectorAll('.e-headercelldiv')[parseInt(j.toString(), 10)];
+            if (headercell.getAttribute('data-mappinguid') === mappingUid) {
+                columnIndex = j;
+            }
+        }
+        return columnIndex;
+    }
+
+    private headerCheckbox(): void {
+        this.columnIndex = this.getCheckboxcolumnIndex();
+        if (this.columnIndex > -1 && this.parent.getHeaderContent().querySelectorAll('.e-treeselectall').length === 0) {
+            const headerElement: Element = this.parent.getHeaderContent().querySelectorAll('.e-headercelldiv')[this.columnIndex];
+            const value: boolean = false;
+            const rowChkBox: Element = this.parent.createElement('input', { className: 'e-treeselectall', attrs: { 'type': 'checkbox'}});
+            const checkWrap: Element = createCheckBox(this.parent.createElement, false, { checked: value as boolean, label: ' ' });
+            checkWrap.classList.add('e-hierarchycheckbox');
+            checkWrap.insertBefore(rowChkBox.cloneNode(), checkWrap.firstChild);
+            if (!isNullOrUndefined(headerElement)) {
+                headerElement.insertBefore(checkWrap, headerElement.firstChild);
+            }
+            if (this.parent.autoCheckHierarchy) {
+                this.headerSelection();
+            }
+        } else if (this.columnIndex > -1 && this.parent.getHeaderContent().querySelectorAll('.e-treeselectall').length > 0) {
+            const checkWrap: Element = this.parent.getHeaderContent().querySelectorAll('.e-checkbox-wrapper')[0];
+            const checkBoxvalue: boolean = checkWrap.querySelector('.e-frame').classList.contains('e-check');
+            if (this.parent.autoCheckHierarchy && checkBoxvalue) {
+                this.headerSelection(checkBoxvalue);
+            }
+        }
+    }
+
+    private renderColumnCheckbox(args: QueryCellInfoEventArgs): Element {
+        const rowChkBox: Element = this.parent.createElement('input', { className: 'e-treecheckselect', attrs: { 'type': 'checkbox', 'aria-label': 'checkbox' }});
+        const data: ITreeData = <ITreeData>args.data;
+        args.cell.classList.add('e-treegridcheckbox');
+        args.cell.setAttribute('aria-label', 'checkbox');
+        const value: boolean = (isNullOrUndefined(data.checkboxState) || data.checkboxState === 'uncheck') ? false : true;
+        const checkWrap: Element = createCheckBox(this.parent.createElement, false, { checked: value as boolean, label: ' ' });
+        checkWrap.classList.add('e-hierarchycheckbox');
+        if (this.parent.allowTextWrap) {
+            (<HTMLElement>checkWrap.querySelector('.e-frame')).style.width = '18px';
+        }
+        if (data.checkboxState === 'indeterminate') {
+            const checkbox: HTMLElement = <HTMLElement>checkWrap.querySelectorAll('.e-frame')[0];
+            removeClass([checkbox], ['e-check', 'e-stop', 'e-uncheck']);
+            checkWrap.querySelector('.e-frame').classList.add('e-stop');
+        }
+        checkWrap.insertBefore(rowChkBox.cloneNode(), checkWrap.firstChild);
+        return checkWrap;
+    }
+
+    private columnCheckbox(container: QueryCellInfoEventArgs): void {
+        const checkWrap: Element = this.renderColumnCheckbox(container);
+        const containerELe: Element = container.cell.querySelector('.e-treecolumn-container');
+        if (!isNullOrUndefined(containerELe)) {
+            if (!container.cell.querySelector('.e-hierarchycheckbox')) {
+                containerELe.insertBefore(checkWrap, containerELe.querySelectorAll('.e-treecell')[0]);
+            }
+        } else {
+            const spanEle: HTMLElement = this.parent.createElement('span', { className: 'e-treecheckbox' });
+            const data: string = container.cell.innerHTML;
+            container.cell.innerHTML = '';
+            spanEle.innerHTML = data;
+            const divEle: HTMLElement = this.parent.createElement('div', { className: 'e-treecheckbox-container' });
+            divEle.appendChild(checkWrap);
+            divEle.appendChild(spanEle);
+            container.cell.appendChild(divEle);
+        }
+    }
+
+    public selectCheckboxes(rowIndexes: number[]): void {
+        if (isNullOrUndefined(rowIndexes)) {
+            const error: string = 'The provided value for the rowIndexes is undefined. Please ensure the rowIndexes contains number.';
+            this.parent.trigger(events.actionFailure, { error: error });
+        }
+        for (let i: number = 0; i < rowIndexes.length; i++) {
+            let record: ITreeData = this.parent.getCurrentViewRecords()[rowIndexes[parseInt(i.toString(), 10)]];
+            const flatRecord: ITreeData = getParentData(this.parent, record.uniqueID);
+            record = flatRecord;
+            const checkboxState: string = (record.checkboxState === 'uncheck') ? 'check' : 'uncheck';
+            record.checkboxState = checkboxState;
+            const keys: string[] = Object.keys(record);
+            for (let j: number = 0; j < keys.length; j++) {
+                if (Object.prototype.hasOwnProperty.call(flatRecord, keys[parseInt(j.toString(), 10)])) {
+                    flatRecord[keys[parseInt(j.toString(), 10)]] = record[keys[parseInt(j.toString(), 10)]];
+                }
+            }
+            this.traverSelection(record, checkboxState, false);
+            if (this.parent.autoCheckHierarchy) {
+                this.headerSelection();
+            }
+        }
+    }
+
+    private traverSelection(record: ITreeData, checkboxState: string, ischildItem: boolean): void {
+        let length: number = 0;
+        this.updateSelectedItems(record, checkboxState);
+        if (!ischildItem && record.parentItem && this.parent.autoCheckHierarchy) {
+            this.updateParentSelection(record.parentItem);
+        }
+        if (record.childRecords && this.parent.autoCheckHierarchy) {
+            let childRecords: ITreeData[] = record.childRecords;
+            if (!isNullOrUndefined(this.parent.filterModule) &&
+            this.parent.filterModule.filteredResult.length > 0 && this.parent.autoCheckHierarchy) {
+                childRecords = this.getFilteredChildRecords(childRecords);
+            }
+            length = childRecords.length;
+            for (let count: number = 0; count < length; count++) {
+                if (!childRecords[parseInt(count.toString(), 10)].isSummaryRow) {
+                    if (childRecords[parseInt(count.toString(), 10)].hasChildRecords) {
+                        this.traverSelection(childRecords[parseInt(count.toString(), 10)], checkboxState, true);
+                    } else {
+                        this.updateSelectedItems(childRecords[parseInt(count.toString(), 10)], checkboxState);
+                    }
+                }
+            }
+        }
+    }
+
+    private getFilteredChildRecords(childRecords: ITreeData[]): ITreeData[] {
+        const filteredChildRecords: ITreeData[] = childRecords.filter((e: ITreeData) => {
+            return this.parent.filterModule.filteredResult.indexOf(e) > -1;
+        });
+        return filteredChildRecords;
+    }
+
+    private updateParentSelection(parentRecord: ITreeData): void {
+        let length: number = 0; let childRecords: ITreeData[] = [];
+        const record: ITreeData = getParentData(this.parent, parentRecord.uniqueID);
+        if (record && record.childRecords) {
+            childRecords = record.childRecords;
+        }
+        if (!isNullOrUndefined(this.parent.filterModule) &&
+            this.parent.filterModule.filteredResult.length > 0 && this.parent.autoCheckHierarchy) {
+            childRecords = this.getFilteredChildRecords(childRecords);
+        }
+        length = childRecords && childRecords.length;
+        let indeter: number = 0; let checkChildRecords: number = 0;
+        if (!isNullOrUndefined(record)) {
+            for (let i: number = 0; i < childRecords.length; i++) {
+                const currentRecord: ITreeData = getParentData(this.parent, childRecords[parseInt(i.toString(), 10)].uniqueID);
+                const checkBoxRecord: ITreeData = currentRecord;
+                if (!isNullOrUndefined(checkBoxRecord)) {
+                    if (checkBoxRecord.checkboxState === 'indeterminate') {
+                        indeter++;
+                    } else if (checkBoxRecord.checkboxState === 'check') {
+                        checkChildRecords++;
+                    }
+                }
+            }
+            if (indeter > 0 || (checkChildRecords > 0 && checkChildRecords !== length)) {
+                record.checkboxState = 'indeterminate';
+            }
+            else if (checkChildRecords === 0 && (!record.hasFilteredChildRecords || isNullOrUndefined(record.hasFilteredChildRecords)) && !isNullOrUndefined(this.parent['dataResults']['actionArgs']) &&
+            (this.parent['dataResults']['actionArgs'].requestType === 'searching' || this.parent['dataResults']['actionArgs'].requestType === 'filtering') && record.checkboxState === 'check') {
+                record.checkboxState = 'check';
+            }
+            else if ((checkChildRecords === 0 && indeter === 0) || (checkChildRecords === 0 && record.hasFilteredChildRecords && !isNullOrUndefined(this.parent['dataResults']['actionArgs']) &&
+            (this.parent['dataResults']['actionArgs'].requestType === 'searching' || this.parent['dataResults']['actionArgs'].requestType === 'filtering') && record.checkboxState === 'check' )) {
+                record.checkboxState = 'uncheck';
+            } else {
+                record.checkboxState = 'check';
+            }
+            this.updateSelectedItems(record, record.checkboxState);
+            if (record.parentItem) {
+                this.updateParentSelection(record.parentItem);
+            }
+        }
+    }
+
+    private headerSelection(checkAll?: boolean): void {
+        let index: number = -1; let length: number = 0;
+        //This property used to maintain the check state of the currentview data after clear filtering
+        let multiFilterCheckState: boolean = false;
+        if (!isNullOrUndefined(this.parent.filterModule) && this.parent.filterModule.filteredResult.length > 0) {
+            const filterResult: Object[] = this.parent.filterModule.filteredResult;
+            if (this.filteredList.length === 0){
+                this.filteredList = filterResult;
+            }
+            if (this.parent.grid.searchSettings.key.length) {
+                this.searchingRecords = filterResult;
+            }
+            else {
+                if (this.filteredList !== filterResult) {
+                    this.filteredList = filterResult;
+                    multiFilterCheckState = true;
+                }
+                else {
+                    multiFilterCheckState = false;
+                }
+            }
+        }
+        if (this.filteredList.length > 0){
+            if (!this.parent.filterSettings.columns.length && this.filteredList.length && !this.parent.grid.searchSettings.key.length){
+                this.filteredList = [];
+            }
+            if (this.searchingRecords.length && !isNullOrUndefined(checkAll)) {
+                this.filteredList = this.searchingRecords;
+            }
+        }
+        let data: ITreeData[];
+        if (!(isNullOrUndefined(this.parent.filterModule)) &&
+        this.parent.filterModule.filteredResult.length === 0 && this.parent.getCurrentViewRecords().length === 0 &&
+        this.parent.filterSettings.columns.length > 0) {
+            data = this.filteredList;
+        }
+        else {
+            data = (!isNullOrUndefined(this.parent.filterModule) &&
+            (this.filteredList.length > 0)) ? this.filteredList : this.parent.flatData;
+        }
+        data = isRemoteData(this.parent) ? this.parent.getCurrentViewRecords() : data;
+        if (!isNullOrUndefined(checkAll)) {
+            for (let i: number = 0; i < data.length; i++) {
+                if (checkAll) {
+                    if (data[parseInt(i.toString(), 10)].checkboxState === 'check') {
+                        continue;
+                    }
+                    if (multiFilterCheckState) {
+                        continue;
+                    }
+                    data[parseInt(i.toString(), 10)].checkboxState = 'check';
+                    this.updateSelectedItems(data[parseInt(i.toString(), 10)], data[parseInt(i.toString(), 10)].checkboxState);
+                } else {
+                    index = this.selectedItems.indexOf(data[parseInt(i.toString(), 10)]);
+                    if (index > -1) {
+                        data[parseInt(i.toString(), 10)].checkboxState = 'uncheck';
+                        this.updateSelectedItems(data[parseInt(i.toString(), 10)], data[parseInt(i.toString(), 10)].checkboxState);
+                        if (this.parent.autoCheckHierarchy) {
+                            this.updateParentSelection(data[parseInt(i.toString(), 10)]);
+                        }
+                    }
+                }
+            }
+        }
+        if (checkAll === false && this.parent.enableVirtualization) {
+            this.selectedItems = [];
+            this.selectedIndexes = [];
+            data.filter((rec: ITreeData) => {
+                rec.checkboxState = 'uncheck';
+                this.updateSelectedItems(rec, rec.checkboxState);
+            });
+        }
+        length = this.selectedItems.length;
+        const checkbox: HTMLElement = <HTMLElement>this.parent.getHeaderContent().querySelectorAll('.e-frame')[0];
+        if (length > 0 && data.length > 0) {
+            if (length !== data.length && !checkAll) {
+                removeClass([checkbox], ['e-check']);
+                checkbox.classList.add('e-stop');
+            } else {
+                removeClass([checkbox], ['e-stop']);
+                checkbox.classList.add('e-check');
+            }
+        } else {
+            removeClass([checkbox], ['e-check', 'e-stop']);
+        }
+    }
+
+    private updateSelectedItems(currentRecord: ITreeData, checkState: string): void {
+        const record: ITreeData[] = this.parent.grid.currentViewData.filter((e: ITreeData) => {
+            return e.uniqueID === currentRecord.uniqueID;
+        });
+        let checkedRecord: ITreeData;
+        const recordIndex: number = this.parent.grid.currentViewData.indexOf(record[0]);
+        const checkboxRecord: ITreeData = getParentData(this.parent, currentRecord.uniqueID);
+        const tr: HTMLElement = this.parent.getRows()[parseInt(recordIndex.toString(), 10)];
+        let checkbox: HTMLElement;
+        if (recordIndex > -1) {
+            let movableTr: Element;
+            if (this.parent.frozenRows || this.parent.getFrozenColumns()) {
+                movableTr = this.parent.getDataRows()[parseInt(recordIndex.toString(), 10)];
+            }
+            checkbox = <HTMLElement>tr.querySelectorAll('.e-hierarchycheckbox .e-frame')[0] ? <HTMLElement>tr.querySelectorAll('.e-hierarchycheckbox .e-frame')[0]
+                : <HTMLElement>movableTr.querySelectorAll('.e-hierarchycheckbox .e-frame')[0];
+            if (!isNullOrUndefined(checkbox)) {
+                removeClass([checkbox], ['e-check', 'e-stop', 'e-uncheck']);
+            }
+        }
+        checkedRecord =  checkboxRecord;
+        if (isNullOrUndefined(checkedRecord)) {
+            checkedRecord = currentRecord;
+        }
+        checkedRecord.checkboxState = checkState;
+        if (checkState === 'check' && isNullOrUndefined(currentRecord.isSummaryRow)) {
+            if (recordIndex !== -1 && this.selectedIndexes.indexOf(recordIndex) === -1) {
+                this.selectedIndexes.push(recordIndex);
+            }
+            if (this.selectedItems.indexOf(checkedRecord) === -1 && (recordIndex !== -1 &&
+            (!isNullOrUndefined(this.parent.filterModule) && this.parent.filterModule.filteredResult.length > 0))) {
+                this.selectedItems.push(checkedRecord);
+            }
+            if (this.selectedItems.indexOf(checkedRecord) === -1 && (this.parent.enableVirtualization || this.parent.allowPaging) && (
+                (!isNullOrUndefined(this.parent.filterModule) && this.parent.filterModule.filteredResult.length > 0))) {
+                this.selectedItems.push(checkedRecord);
+            }
+            if (this.selectedItems.indexOf(checkedRecord) === -1 && (!isNullOrUndefined(this.parent.filterModule) &&
+            this.parent.filterModule.filteredResult.length === 0)) {
+                this.selectedItems.push(checkedRecord);
+            }
+            if (this.selectedItems.indexOf(checkedRecord) === -1 && isNullOrUndefined(this.parent.filterModule)) {
+                this.selectedItems.push(checkedRecord);
+            }
+        } else if ((checkState === 'uncheck' || checkState === 'indeterminate') && isNullOrUndefined(currentRecord.isSummaryRow)) {
+            const index: number = this.selectedItems.indexOf(checkedRecord);
+            if (index !== -1) {
+                this.selectedItems.splice(index, 1);
+            }
+            if (this.selectedIndexes.indexOf(recordIndex) !== -1) {
+                const checkedIndex: number = this.selectedIndexes.indexOf(recordIndex);
+                this.selectedIndexes.splice(checkedIndex, 1);
+            }
+        }
+        const checkBoxclass: string = checkState ===  'indeterminate' ? 'e-stop' : 'e-' + checkState;
+        if (recordIndex > -1) {
+            if (!isNullOrUndefined(checkbox)) {
+                checkbox.classList.add(checkBoxclass);
+                tr.querySelector('.e-treecheckselect').setAttribute('aria-checked', checkState === 'check' ? 'true' : checkState === 'uncheck' ? 'false' : 'mixed');
+            }
+        }
+    }
+
+    private updateGridActions(args: CellSaveEventArgs): void {
+        const requestType: string = args.requestType; let childData: ITreeData[]; let childLength: number;
+        if (isCheckboxcolumn(this.parent)) {
+            if (this.parent.autoCheckHierarchy) {
+                if ((requestType === 'sorting' || requestType === 'paging')) {
+                    const rows: Element[] = this.parent.grid.getRows();
+                    childData = this.parent.getCurrentViewRecords();
+                    childLength = childData.length;
+                    this.selectedIndexes = [];
+                    for (let i: number = 0; i < childLength; i++) {
+                        if (!rows[parseInt(i.toString(), 10)].classList.contains('e-summaryrow')) {
+                            this.updateSelectedItems(childData[parseInt(i.toString(), 10)],
+                                                     childData[parseInt(i.toString(), 10)].checkboxState);
+                        }
+                    }
+                } else if (requestType === 'delete' || args.action === 'add') {
+                    let updatedData: ITreeData[] = [];
+                    if (requestType === 'delete') {
+                        updatedData = <ITreeData[]>args.data;
+                    } else {
+                        updatedData.push(args.data);
+                    }
+                    for (let i: number = 0; i < updatedData.length; i++) {
+                        if (requestType === 'delete') {
+                            const index: number = this.parent.flatData.indexOf(updatedData[parseInt(i.toString(), 10)]);
+                            const checkedIndex: number = this.selectedIndexes.indexOf(index);
+                            this.selectedIndexes.splice(checkedIndex, 1);
+                            this.updateSelectedItems(updatedData[parseInt(i.toString(), 10)], 'uncheck');
+                        }
+                        if (!isNullOrUndefined(updatedData[parseInt(i.toString(), 10)].parentItem)) {
+                            this.updateParentSelection(updatedData[parseInt(i.toString(), 10)].parentItem);
+                        }
+                    }
+                } else if (args.requestType === 'add' && this.parent.autoCheckHierarchy) {
+                    (<ITreeData>args.data).checkboxState = 'uncheck';
+                } else if (requestType === 'filtering' || requestType === 'searching' || requestType === 'refresh'
+                     && !isRemoteData(this.parent)) {
+                    this.selectedItems = []; this.selectedIndexes = [];
+                    childData = (!isNullOrUndefined(this.parent.filterModule) && this.parent.filterModule.filteredResult.length > 0) ?
+                        this.parent.filterModule.filteredResult : this.parent.flatData;
+                    childData.forEach((record: ITreeData) => {
+                        if (this.parent.enableVirtualization) {
+                            if (record.hasChildRecords && record.childRecords.length > 0) {
+                                this.updateParentSelection(record);
+                            } else {
+                                this.updateSelectedItems(record, record.checkboxState);
+                            }
+                            let child: ITreeData[] = findChildrenRecords(record);
+                            child = this.getFilteredChildRecords (child);
+                            for (let i: number = 0; i < child.length; i++) {
+                                if (child[parseInt(i.toString(), 10)].hasChildRecords) {
+                                    this.updateParentSelection(child[parseInt(i.toString(), 10)]);
+                                } else if (!(child[parseInt(i.toString(), 10)].hasChildRecords) &&
+                                           !isNullOrUndefined(child[parseInt(i.toString(), 10)])) {
+                                    this.updateSelectedItems(child[parseInt(i.toString(), 10)],
+                                                             child[parseInt(i.toString(), 10)].checkboxState);
+                                }
+                            }
+                        }
+                        else {
+                            if (record.hasChildRecords) {
+                                this.updateParentSelection(record);
+                            } else {
+                                this.updateSelectedItems(record, record.checkboxState);
+                            }
+                        }
+                    });
+                    this.headerSelection();
+                }
+            }
+            else {
+                if ((requestType === 'filtering' || requestType === 'searching' || requestType === 'refresh')
+                    && !isRemoteData(this.parent)) {
+                    this.selectedItems = [];
+                    this.selectedIndexes = [];
+                }
+            }
+        }
+    }
+
+    public getCheckedrecords(): Object[] {
+        return this.selectedItems;
+    }
+
+    public getCheckedRowIndexes(): number[] {
+        return this.selectedIndexes;
+    }
+}

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

@@ -0,0 +1,63 @@
+import { TreeGrid } from '../base/treegrid';
+import { SortDirection } from '@syncfusion/ej2-grids';
+/**
+ * Internal dataoperations for TreeGrid
+ *
+ * @hidden
+ */
+export declare class Sort {
+    private flatSortedData;
+    private taskIds;
+    private storedIndex;
+    private parent;
+    private isSelfReference;
+    constructor(grid: TreeGrid);
+    /**
+     * For internal use only - Get the module name.
+     *
+     * @private
+     * @returns {string} Returns Sort module name
+     */
+    private getModuleName;
+    /**
+     * @hidden
+     */
+    addEventListener(): void;
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    removeEventListener(): void;
+    private createdSortedRecords;
+    private iterateSort;
+    /**
+     * Sorts a column with the given options.
+     *
+     * @param {string} columnName - Defines the column name to be sorted.
+     * @param {SortDirection} direction - Defines the direction of sorting field.
+     * @param {boolean} isMultiSort - Specifies whether the previous sorted columns are to be maintained.
+     * @returns {void}
+     */
+    sortColumn(columnName: string, direction: SortDirection, isMultiSort?: boolean): void;
+    removeSortColumn(field: string): void;
+    /**
+     * The function used to update sortSettings of TreeGrid.
+     *
+     * @returns {void}
+     * @hidden
+     */
+    private updateModel;
+    /**
+     * Clears all the sorted columns of the TreeGrid.
+     *
+     * @returns {void}
+     */
+    clearSorting(): void;
+    /**
+     * Destroys the Sorting of TreeGrid.
+     *
+     * @function destroy
+     * @returns {void}
+     */
+    destroy(): void;
+}