@syncfusion/ej2-treegrid 30.2.4 → 31.1.17

package/dist/ts/treegrid/renderer/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Renderer export
+ */
+export * from './render';
+export * from './virtual-row-model-generator';

package/dist/ts/treegrid/renderer/render.d.ts

@@ -0,0 +1,41 @@
+import { TreeGrid } from '..';
+import { QueryCellInfoEventArgs, RowDataBoundEventArgs } from '@syncfusion/ej2-grids';
+/**
+ * TreeGrid render module
+ *
+ * @hidden
+ */
+export declare class Render {
+    private parent;
+    private templateResult;
+    /**
+     * Constructor for render module
+     *
+     * @param {TreeGrid} parent - Tree Grid instance
+     */
+    constructor(parent?: TreeGrid);
+    /**
+     * Updated row elements for TreeGrid
+     *
+     * @param {RowDataBoundEventArgs} args - Row details before its bound to DOM
+     * @returns {void}
+     */
+    RowModifier(args: RowDataBoundEventArgs): void;
+    /**
+     * cell renderer for tree column index cell
+     *
+     * @param {QueryCellInfoEventArgs} args - Cell detail before its bound to DOM
+     * @returns {void}
+     */
+    cellRender(args: QueryCellInfoEventArgs): void;
+    private updateTreeCell;
+    /**
+     * @param {string} columnUid - Defines column uid
+     * @returns {void}
+     * @hidden
+     */
+    private refreshReactColumnTemplateByUid;
+    private columnTemplateResult;
+    private reactTemplateRender;
+    destroy(): void;
+}

package/dist/ts/treegrid/renderer/render.ts

@@ -0,0 +1,379 @@
+import { TreeGrid } from '..';
+import { QueryCellInfoEventArgs, IGrid, RowDataBoundEventArgs, getObject, appendChildren } from '@syncfusion/ej2-grids';
+import { templateCompiler, extend, Row, CellRenderer, Cell } from '@syncfusion/ej2-grids';
+import { addClass, createElement, isNullOrUndefined, getValue } from '@syncfusion/ej2-base';
+import { ITreeData } from '../base/interface';
+import * as events from '../base/constant';
+import { isRemoteData, isOffline, getExpandStatus, isFilterChildHierarchy } from '../utils';
+import { Column } from '../models';
+import { Column as gridColumn } from '@syncfusion/ej2-grids';
+
+/**
+ * TreeGrid render module
+ *
+ * @hidden
+ */
+export class Render {
+    //Module declarations
+    private parent: TreeGrid;
+    private templateResult: NodeList;
+    /**
+     * Constructor for render module
+     *
+     * @param {TreeGrid} parent - Tree Grid instance
+     */
+    constructor(parent?: TreeGrid) {
+        this.parent = parent;
+        this.templateResult = null;
+        this.parent.grid.on('template-result', this.columnTemplateResult, this);
+        this.parent.grid.on('reactTemplateRender', this.reactTemplateRender, this);
+    }
+    /**
+     * Updated row elements for TreeGrid
+     *
+     * @param {RowDataBoundEventArgs} args - Row details before its bound to DOM
+     * @returns {void}
+     */
+    public RowModifier(args: RowDataBoundEventArgs): void {
+        if  (!args.data) {
+            return;
+        }
+        const data: ITreeData = <ITreeData>args.data;
+        const parentData: ITreeData = <ITreeData>data.parentItem;
+        if (!isNullOrUndefined(data.parentItem) && !isFilterChildHierarchy(this.parent) &&
+            (!(this.parent.allowPaging && !(this.parent.pageSettings.pageSizeMode === 'Root')) ||
+                (isRemoteData(this.parent) && !isOffline(this.parent))))  {
+            const collapsed: boolean = (this.parent.initialRender && (!(isNullOrUndefined(parentData[this.parent.expandStateMapping]) ||
+                             parentData[this.parent.expandStateMapping]) || this.parent.enableCollapseAll)) ||
+                            !getExpandStatus(this.parent, args.data, this.parent.grid.getCurrentViewRecords());
+            if (collapsed && !isNullOrUndefined(args.row)) {
+                this.parent['toggleRowVisibility'](<HTMLTableRowElement>args.row, 'e-childrow-hidden');
+                const rowsObj: Row<gridColumn>[] = this.parent.grid.getRowsObject();
+                if (!this.parent.grid.isFrozenGrid() && !isNullOrUndefined(args.row.getAttribute('data-uid'))) {
+                    rowsObj.filter((e : Row<gridColumn>) => e.uid === args.row.getAttribute('data-uid'))[0].visible = false;
+                }
+            }
+        }
+        if (isRemoteData(this.parent) && !isOffline(this.parent)) {
+            const proxy: TreeGrid = this.parent;
+            const parentrec: ITreeData[] = this.parent.getCurrentViewRecords().filter((rec: ITreeData) => {
+                return getValue(proxy.idMapping, rec) === getValue(proxy.parentIdMapping, data);
+            });
+            if (parentrec.length > 0 && !parentrec[0].isSummaryRow && !isNullOrUndefined(args.row)) {
+                const display: string = parentrec[0].expanded ? 'e-childrow-visible' : 'e-childrow-hidden';
+                this.parent['toggleRowVisibility'](<HTMLTableRowElement>args.row, display);
+            }
+        }
+        //addClass([args.row], 'e-gridrowindex' + index + 'level' + (<ITreeData>args.data).level);
+        const summaryRow: boolean = getObject('isSummaryRow', args.data);
+        if (summaryRow) {
+            addClass([args.row], 'e-summaryrow');
+        }
+        if (!isNullOrUndefined(args.row)) {
+            if (args.row.querySelector('.e-treegridexpand')) {
+                args.row.setAttribute('aria-expanded', 'true');
+            } else if (args.row.querySelector('.e-treegridcollapse')) {
+                args.row.setAttribute('aria-expanded', 'false');
+            }
+            if (this.parent.enableCollapseAll && this.parent.initialRender) {
+                if (!isNullOrUndefined(data.parentItem)) {
+                    this.parent['toggleRowVisibility'](<HTMLTableRowElement>args.row, 'e-childrow-hidden');
+                }
+            }
+        }
+        const dragStartData: string = 'dragStartData';
+        const draggedRecord: string = 'draggedRecord';
+        if (this.parent.rowDragAndDropModule && this.parent.grid.rowDragAndDropModule && (this.parent.grid.rowDragAndDropModule[`${dragStartData}`] ||
+        this.parent.rowDragAndDropModule[`${draggedRecord}`]) && this.parent.getContentTable().scrollHeight <= this.parent.getContent().clientHeight) {
+            const lastRowBorder: string = 'lastRowBorder';
+            const lastVisualData: ITreeData = this.parent.getVisibleRecords()[this.parent.getVisibleRecords().length - 1];
+            if (lastVisualData.uniqueID === (args.data as ITreeData).uniqueID && !isNullOrUndefined(args.row as HTMLTableRowElement) && !(args.row as HTMLTableRowElement).cells[0].classList.contains('e-lastrowcell')) {
+                this.parent[`${lastRowBorder}`](args.row as HTMLTableRowElement, true);
+            }
+        }
+        if ((<{ isReact?: boolean }>this.parent).isReact) {
+            const renderReactTemplates: string = 'renderReactTemplates';
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const thisRef: Render = this;
+            // tslint:disable-next-line:typedef
+            thisRef.parent[`${renderReactTemplates}`](function () {
+                thisRef.parent.trigger(events.rowDataBound, args);
+            });
+        } else {
+            this.parent.trigger(events.rowDataBound, args);
+        }
+    }
+    /**
+     * cell renderer for tree column index cell
+     *
+     * @param {QueryCellInfoEventArgs} args - Cell detail before its bound to DOM
+     * @returns {void}
+     */
+    public cellRender(args: QueryCellInfoEventArgs): void {
+        if  (!args.data) {
+            return;
+        }
+        const grid: IGrid = this.parent.grid; const data: ITreeData = <ITreeData>args.data; let index: number;
+        const ispadfilter: boolean = isNullOrUndefined(data.filterLevel);
+        const pad: number = ispadfilter ? data.level : data.filterLevel;
+        let totalIconsWidth: number = 0; let cellElement: HTMLElement;
+        const column: Column = this.parent.getColumnByUid(args.column.uid);
+        const summaryRow: boolean = data.isSummaryRow; const frozenColumns: number = this.parent.getFrozenColumns();
+        if (!isNullOrUndefined(data.parentItem)) {
+            index = data.parentItem.index;
+        } else { index = data.index; }
+        let columnIndex: number; const getVirtualColIndexByUid: string = 'getVirtualColIndexByUid';
+        if (this.parent.enableColumnVirtualization && !this.parent.initialRender) {
+            columnIndex = this.parent[`${getVirtualColIndexByUid}`](args.column.uid);
+        } else {
+            columnIndex = grid.getColumnIndexByUid(args.column.uid);
+        }
+        if (columnIndex === this.parent.treeColumnIndex  && (args.requestType === 'add' || args.requestType
+            === 'rowDragAndDrop' || args.requestType === 'delete' || isNullOrUndefined(args.cell.querySelector('.e-treecell')))) {
+            const container: Element = createElement('div', { className: 'e-treecolumn-container' });
+            const emptyExpandIcon: HTMLElement = createElement('span', { className: 'e-icons e-none' });
+            emptyExpandIcon.style.width = '10px';
+            emptyExpandIcon.style.display = 'inline-block';
+            for (let n: number = 0; n < pad; n++) {
+                totalIconsWidth += 10;
+                container.appendChild(emptyExpandIcon.cloneNode());
+            }
+            let iconRequired: boolean = !isNullOrUndefined(data.hasFilteredChildRecords)
+                ? data.hasFilteredChildRecords : data.hasChildRecords;
+            if (iconRequired && !isNullOrUndefined(data.childRecords)) {
+                if (this.parent['isFromGantt'] && this.parent.loadChildOnDemand) {
+                    iconRequired = data.hasChildRecords;
+                }
+                else {
+                    iconRequired = !((<ITreeData>data).childRecords.length === 0 );
+                }
+            }
+            if (iconRequired) {
+                addClass([args.cell], 'e-treerowcell');
+                args.cell.setAttribute('aria-expanded', data.expanded ? 'true' : 'false');
+                const expandIcon: Element = createElement('span', { className: 'e-icons' });
+                let expand: boolean;
+                if (this.parent.initialRender) {
+                    expand = data.expanded &&
+                        (isNullOrUndefined(data[this.parent.expandStateMapping]) || data[this.parent.expandStateMapping]) &&
+                        !this.parent.enableCollapseAll;
+                } else {
+                    expand =  !(!data.expanded || !getExpandStatus(this.parent, data, this.parent.grid.getCurrentViewRecords()));
+                    // TicketsID 43483: While Modify Data Expand and Collapse Icon Behavior Changed
+                    if (this.parent.editSettings.mode === 'Cell' && !isRemoteData(this.parent)) {
+                        const selectedRow: ITreeData = this.parent.flatData.find((item: ITreeData) => item.uniqueID === data.uniqueID);
+                        if (!isNullOrUndefined(selectedRow)) {
+                            expand = data.expanded !== selectedRow.expanded ? selectedRow.expanded : data.expanded;
+                        }
+                    }
+                }
+                addClass([expandIcon], (expand ) ? 'e-treegridexpand' : 'e-treegridcollapse');
+                totalIconsWidth += 18;
+                container.appendChild(expandIcon);
+                emptyExpandIcon.style.width = '4px'; totalIconsWidth += 7;
+                container.appendChild(emptyExpandIcon.cloneNode());
+            } else if (pad || !pad && !data.level) {
+                // icons width
+                totalIconsWidth += 20;
+                container.appendChild(emptyExpandIcon.cloneNode());
+                container.appendChild(emptyExpandIcon.cloneNode());
+            }
+            //should add below code when paging funcitonality implemented
+            // if (data.hasChildRecords) {
+            //     addClass([expandIcon], data.expanded ? 'e-treegridexpand' : 'e-treegridcollapse');
+            // }
+            cellElement = createElement('span', { className: 'e-treecell' });
+            if (this.parent.allowTextWrap) {
+                cellElement.style.width = 'Calc(100% - ' + totalIconsWidth + 'px)';
+            }
+            addClass([args.cell], 'e-gridrowindex' + index + 'level' + data.level);
+            this.updateTreeCell(args, cellElement);
+            container.appendChild(cellElement);
+            args.cell.appendChild(container);
+        } else if (this.templateResult) {
+            this.templateResult = null;
+        }
+        const freeze: boolean = (grid.getFrozenLeftColumnsCount() > 0 || grid.getFrozenRightColumnsCount() > 0 ) ? true : false;
+        if (!freeze) {
+            if (frozenColumns > this.parent.treeColumnIndex && frozenColumns > 0 &&
+                grid.getColumnIndexByUid(args.column.uid) === frozenColumns) {
+                addClass([args.cell], 'e-gridrowindex' + index + 'level' + data.level);
+            } else if (frozenColumns < this.parent.treeColumnIndex && frozenColumns > 0 &&
+                (grid.getColumnIndexByUid(args.column.uid) === frozenColumns
+                    || grid.getColumnIndexByUid(args.column.uid) === frozenColumns - 1)) {
+                addClass([args.cell], 'e-gridrowindex' + index + 'level' + data.level);
+            } else if (frozenColumns === this.parent.treeColumnIndex && frozenColumns > 0 &&
+                grid.getColumnIndexByUid(args.column.uid) === this.parent.treeColumnIndex - 1) {
+                addClass([args.cell], 'e-gridrowindex' + index + 'level' + data.level);
+            }
+        } else {
+            const freezerightColumns: gridColumn[] = grid.getFrozenRightColumns();
+            const freezeLeftColumns: gridColumn[] = grid.getFrozenLeftColumns();
+            const movableColumns: gridColumn[] = grid.getMovableColumns();
+            if ((freezerightColumns.length > 0) && freezerightColumns[0].field === args.column.field) {
+                addClass([args.cell], 'e-gridrowindex' + index + 'level' + data.level);
+            } else if ((freezeLeftColumns.length > 0) && freezeLeftColumns[0].field === args.column.field) {
+                addClass([args.cell], 'e-gridrowindex' + index + 'level' + data.level);
+            } else if ((movableColumns.length > 0) && movableColumns[0].field === args.column.field) {
+                addClass([args.cell], 'e-gridrowindex' + index + 'level' + data.level);
+            }
+        }
+        if (!isNullOrUndefined(column) && column.showCheckbox) {
+            this.parent.notify('columnCheckbox', args);
+            if (this.parent.allowTextWrap) {
+                const checkboxElement: HTMLElement = <HTMLElement>args.cell.querySelectorAll('.e-frame')[0];
+                const width: number = parseInt(checkboxElement.style.width, 16);
+                totalIconsWidth += width; totalIconsWidth += 10;
+                if (grid.getColumnIndexByUid(args.column.uid) === this.parent.treeColumnIndex) {
+                    cellElement = <HTMLElement>args.cell.querySelector('.e-treecell');
+                } else {
+                    cellElement = <HTMLElement>args.cell.querySelector('.e-treecheckbox');
+                }
+                cellElement.style.width = 'Calc(100% - ' + totalIconsWidth + 'px)';
+            }
+        }
+        if (summaryRow) {
+            addClass([args.cell], 'e-summarycell');
+            let summaryData: string = getObject(args.column.field, args.data);
+            summaryData = isNullOrUndefined(summaryData) ? null : summaryData;
+            if (args.cell.querySelector('.e-treecell') != null) {
+                args.cell.querySelector('.e-treecell').innerHTML = summaryData;
+            } else {
+                if (args.column.template) {
+                    args.cell.innerHTML = null;
+                }
+                else {
+                    args.cell.innerHTML = summaryData;
+                }
+            }
+        }
+        this.parent['args'] = args;
+        const columnModel: Column[] = getValue('columnModel', this.parent);
+        const treeColumn: Column = columnModel[this.parent.treeColumnIndex];
+        if ((isNullOrUndefined(this.parent.rowTemplate) && !((<{ isReact?: boolean }>this.parent).isReact))
+            || (((<{ isReact?: boolean }>this.parent).isReact) &&
+                !args.column['template'])) {
+            this.parent.trigger(events.queryCellInfo, args);
+        } else if ((((<{ isReact?: boolean }>this.parent).isReact) &&
+            treeColumn.field !== args.column.field)) {
+            const renderReactTemplates: string = 'renderReactTemplates';
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const thisRef: Render = this;
+            // tslint:disable-next-line:typedef
+            thisRef.parent[`${renderReactTemplates}`](function () {
+                thisRef.parent.trigger(events.queryCellInfo, args);
+            });
+        }
+    }
+    private updateTreeCell(args: QueryCellInfoEventArgs, cellElement: HTMLElement): void {
+        const columnModel: Column[] = getValue('columnModel', this.parent);
+        const treeColumn: Column = columnModel[this.parent.treeColumnIndex];
+        const templateFn: string = 'templateFn';
+        const colindex: number = args.column.index;
+        if (isNullOrUndefined(treeColumn.field)) {
+            args.cell.setAttribute('aria-colindex', (colindex + 1) + '');
+        }
+        if (treeColumn.field === args.column.field && !isNullOrUndefined(treeColumn.template)) {
+            /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+            args.column.template = treeColumn.template as any;
+            args.column[`${templateFn}`] = templateCompiler(args.column.template);
+            args.cell.classList.add('e-templatecell');
+        }
+        const textContent: string = args.cell.querySelector('.e-treecell') != null ?
+            args.cell.querySelector('.e-treecell').innerHTML : args.cell.innerHTML;
+        if ( typeof(args.column.template) === 'object' && this.templateResult ) {
+            appendChildren(cellElement , this.templateResult);
+            this.templateResult = null;
+            args.cell.innerHTML = '';
+        } else if (args.cell.classList.contains('e-templatecell')) {
+            let len: number = args.cell.children.length;
+            const tempID: string = this.parent.element.id + args.column.uid;
+            if (treeColumn.field === args.column.field && !isNullOrUndefined(treeColumn.template)) {
+                const portals: string = 'portals';
+                const renderReactTemplates: string = 'renderReactTemplates';
+                if ((<{ isReact?: boolean }>this.parent).isReact && typeof (args.column.template) !== 'string') {
+                    args.column[`${templateFn}`](args.data, this.parent, 'columnTemplate', tempID, null, null, cellElement);
+                    if (isNullOrUndefined(this.parent.grid[`${portals}`])) {
+                        this.parent.grid[`${portals}`] = this.parent[`${portals}`];
+                    }
+                    this.parent.notify('renderReactTemplate', this.parent[`${portals}`]);
+                    // eslint-disable-next-line @typescript-eslint/no-this-alias
+                    const thisRef: Render = this;
+                    // tslint:disable-next-line:typedef
+                    thisRef.parent[`${renderReactTemplates}`](function () {
+                        thisRef.parent.trigger(events.queryCellInfo, args);
+                    });
+                } else {
+                    const str: string = 'isStringTemplate';
+                    const result: Element[] = args.column[`${templateFn}`](
+                        extend({ 'index': '' }, args.data), this.parent, 'template', tempID, this.parent[`${str}`]);
+                    appendChildren(cellElement, result);
+                }
+                delete args.column.template;
+                delete args.column[`${templateFn}`];
+                args.cell.innerHTML = '';
+            } else {
+                for (let i: number = 0; i < len; len = args.cell.children.length) {
+                    cellElement.appendChild(args.cell.children[parseInt(i.toString(), 10)]);
+                }
+            }
+        } else {
+            cellElement.innerHTML = textContent;
+            args.cell.innerHTML = '';
+        }
+    }
+
+    /**
+     * @param {string} columnUid - Defines column uid
+     * @returns {void}
+     * @hidden
+     */
+    private refreshReactColumnTemplateByUid(columnUid: string): void {
+        if ((<{ isReact?: boolean }>this.parent).isReact) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (this as any).parent.clearTemplate(['columnTemplate'], undefined, () => {
+                const cells: string = 'cells';
+                const rowIdx: string = 'index';
+                const rowsObj: Row<gridColumn>[] = this.parent.grid.getRowsObject();
+                const rows: Element[] = this.parent.getDataRows();
+                const indent: number = this.parent.grid.getIndentCount();
+                const cellIndex: number = this.parent.grid.getNormalizedColumnIndex(columnUid);
+                if (rows.length !== 0) {
+                    for (let j: number = 0; j < rowsObj.length; j++) {
+                        if (rowsObj[parseInt(j.toString(), 10)].isDataRow
+                        && !isNullOrUndefined(rowsObj[parseInt(j.toString(), 10)].index)) {
+                            const cell: Cell<gridColumn> = rowsObj[parseInt(j.toString(), 10)][`${cells}`][parseInt(cellIndex.toString(), 10)];
+                            const cellRenderer: CellRenderer = new CellRenderer(this.parent.grid as IGrid, this.parent.grid.serviceLocator);
+                            const td: Element = rows.length >= rowsObj.length
+                                ? this.parent.getCellFromIndex(rowsObj[parseInt(j.toString(), 10)].index, cellIndex - indent)
+                                : rows[rowsObj[parseInt(j.toString(), 10)].index].querySelector('.e-templatecell');
+                            cellRenderer.refreshTD(td, cell, rowsObj[parseInt(j.toString(), 10)].data, { index: rowsObj[parseInt(j.toString(), 10)][`${rowIdx}`] });
+                            const treecell: Element =
+                                this.parent.getRows()[parseInt(j.toString(), 10)]
+                                    .cells[parseInt(cellIndex.toString(), 10)];
+                            this.cellRender({ data: rowsObj[parseInt(j.toString(), 10)].data, cell: treecell, column: cell.column });
+                        }
+                    }
+                }
+            });
+        }
+    }
+
+    private columnTemplateResult(args: {template : NodeList, name: string}): void {
+        this.templateResult = args.template;
+    }
+
+    // eslint-disable-next-line
+    private reactTemplateRender(args: Object[], callBack?: any): void {
+        const renderReactTemplates: string = 'renderReactTemplates';
+        const portals: string = 'portals';
+        this.parent[`${portals}`] = args;
+        this.parent.notify('renderReactTemplate', this.parent[`${portals}`]);
+        this.parent[`${renderReactTemplates}`](callBack);
+    }
+
+    public destroy(): void {
+        this.parent.grid.off('template-result', this.columnTemplateResult);
+        this.parent.grid.off('reactTemplateRender', this.reactTemplateRender);
+    }
+}

package/dist/ts/treegrid/renderer/virtual-row-model-generator.d.ts

@@ -0,0 +1,16 @@
+import { VirtualRowModelGenerator } from '@syncfusion/ej2-grids';
+import { NotifyArgs, Row, Column, IGrid } from '@syncfusion/ej2-grids';
+/**
+ * RowModelGenerator is used to generate grid data rows.
+ *
+ * @hidden
+ */
+export declare class TreeVirtualRowModelGenerator extends VirtualRowModelGenerator {
+    private visualData;
+    constructor(parent: IGrid);
+    addEventListener(): void;
+    private getDatas;
+    private getDataInfo;
+    generateRows(data: Object[], notifyArgs?: NotifyArgs): Row<Column>[];
+    checkAndResetCache(action: string): boolean;
+}

package/dist/ts/treegrid/renderer/virtual-row-model-generator.ts

@@ -0,0 +1,90 @@
+import { VirtualInfo, VirtualRowModelGenerator } from '@syncfusion/ej2-grids';
+import { NotifyArgs, Row, Column, IGrid, Grid, VirtualContentRenderer } from '@syncfusion/ej2-grids';
+import { ITreeData } from '../base';
+import * as events from '../base/constant';
+import { isNullOrUndefined } from '@syncfusion/ej2-base';
+import { DataManager } from '@syncfusion/ej2-data';
+import { isCountRequired, isRemoteData } from '../utils';
+/**
+ * RowModelGenerator is used to generate grid data rows.
+ *
+ * @hidden
+ */
+
+export class TreeVirtualRowModelGenerator extends VirtualRowModelGenerator {
+    private visualData: ITreeData[];
+    constructor(parent: IGrid) {
+        super(parent);
+        this.addEventListener();
+    }
+    public addEventListener() : void {
+        this.parent.on(events.dataListener, this.getDatas, this);
+    }
+    private getDatas(args: {data: ITreeData[]}): void {
+        this.visualData = args.data;
+    }
+    private getDataInfo(): VirtualInfo{
+        return super.getData();
+    }
+    public generateRows(data: Object[], notifyArgs?: NotifyArgs): Row<Column>[] {
+        const info: VirtualInfo = this.getDataInfo();
+        if (notifyArgs.requestType === 'refresh' && (notifyArgs as any).isExpandCollapse) {
+            notifyArgs.virtualInfo = this['prevInfo'];
+        }
+        if (!isNullOrUndefined(notifyArgs.virtualInfo) && !(this.parent.root.loadChildOnDemand && isRemoteData(this.parent.root))) {
+            if (notifyArgs.virtualInfo.direction !== 'right' && notifyArgs.virtualInfo.direction !== 'left') {
+                if ((!isRemoteData(this.parent.root) || isCountRequired(this.parent))
+                    || notifyArgs.virtualInfo.blockIndexes.length === 1) {
+                    notifyArgs.virtualInfo.blockIndexes = info.blockIndexes;
+                }
+            } else {
+                notifyArgs.virtualInfo.blockIndexes = this.getBlockIndexes(notifyArgs.virtualInfo.page);
+            }
+        }
+        if ((this.parent.dataSource instanceof DataManager && (this.parent.dataSource as DataManager).dataSource.url !== undefined
+        && !(this.parent.dataSource as DataManager).dataSource.offline && (this.parent.dataSource as DataManager).dataSource.url !== '') || isCountRequired(this.parent)) {
+            return super.generateRows(data, notifyArgs);
+        } else {
+            if (!isNullOrUndefined(notifyArgs.requestType) && notifyArgs.requestType.toString() === 'collapseAll') {
+                notifyArgs.requestType = 'refresh';
+            }
+            const rows: Row<Column>[] = super.generateRows(data, notifyArgs);
+            if (!isNullOrUndefined(<ITreeData[]>(this.visualData))) {
+                for (let r: number = 0; r < rows.length; r++) {
+                    rows[parseInt(r.toString(), 10)].index
+                    = (<ITreeData[]>(this.visualData)).indexOf(rows[parseInt(r.toString(), 10)].data);                }
+            }
+            return rows;
+        }
+    }
+    public checkAndResetCache(action: string): boolean {
+        const clear: boolean = ['paging', 'refresh', 'sorting', 'filtering', 'searching', 'reorder',
+            'save', 'delete'].some((value: string) => action === value);
+        if ((this.parent.dataSource instanceof DataManager && (this.parent.dataSource as DataManager).dataSource.url !== undefined
+            && !(this.parent.dataSource as DataManager).dataSource.offline && (this.parent.dataSource as DataManager).dataSource.url !== '') || isCountRequired(this.parent)) {
+            const model: string = 'model';
+            const currentPage: number = this[`${model}`].currentPage;
+            if (clear) {
+                this.cache = {};
+                /*this.movableCache = {};
+                this.frozenRightCache = {};*/
+                this.data = {};
+                this.groups = {};
+            } else if (action === 'virtualscroll' && this.cache[parseInt(currentPage.toString(), 10)] &&
+                this.cache[parseInt(currentPage.toString(), 10)].length >
+                (((this.parent as Grid).contentModule) as VirtualContentRenderer).getBlockSize()) {
+                if (this.cache[parseInt(currentPage.toString(), 10)].length > (this.parent.contentModule).getBlockSize()) {
+                    this.cache[parseInt(currentPage.toString(), 10)] =
+                        this.cache[parseInt(currentPage.toString(), 10)].slice(0, (this.parent.contentModule).getBlockSize());
+                }
+            }
+        } else {
+            if (clear || action === 'virtualscroll') {
+                this.cache = {}; this.data = {}; this.groups = {};
+                /*this.movableCache = {};
+                this.frozenRightCache = {};*/
+            }
+        }
+        return clear;
+    }
+}