@syncfusion/ej2-treegrid 31.1.17 → 31.1.21

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

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

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

@@ -1,41 +0,0 @@
-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

@@ -1,379 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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;
-    }
-}