@syncfusion/ej2-treegrid 20.1.52 → 20.1.56-97113

package/src/treegrid/renderer/virtual-tree-freeze-render.d.ts

@@ -0,0 +1,59 @@
+import { Column, IGrid, NotifyArgs, Row, ServiceLocator } from '@syncfusion/ej2-grids';
+import { ColumnVirtualFreezeRenderer, VirtualFreezeHdrRenderer, VirtualFreezeRenderer } from '@syncfusion/ej2-grids';
+/**
+ * VirtualTreeFreezeRenderer is used to render the virtual table within the frozen and movable content table
+ *
+ * @hidden
+ */
+export declare class VirtualTreeFreezeRenderer extends VirtualFreezeRenderer {
+    protected serviceLoc: ServiceLocator;
+    constructor(parent: IGrid, locator?: ServiceLocator);
+    /**
+     * @returns {void}
+     * @hidden
+     */
+    renderTable(): void;
+    /**
+     * @param {HTMLElement} target - specifies the target
+     * @param {DocumentFragment} newChild - specifies the newChild
+     * @param {NotifyArgs} e - specifies the notifyargs
+     * @returns {void}
+     * @hidden
+     */
+    appendContent(target: HTMLElement, newChild: DocumentFragment, e: NotifyArgs): void;
+    /**
+     * @param {Object[]} data - specifies the data
+     * @param {NotifyArgs} e - specifies the notifyargs
+     * @returns {Row<Column>[]} returns the row
+     * @hidden
+     */
+    generateRows(data: Object[], e?: NotifyArgs): Row<Column>[];
+}
+/**
+ * ColumnVirtualTreeFreezeRenderer is used to render the virtual table within the frozen and movable content table
+ *
+ * @hidden
+ */
+export declare class ColumnVirtualTreeFreezeRenderer extends ColumnVirtualFreezeRenderer {
+    protected serviceLoc: ServiceLocator;
+    constructor(parent?: IGrid, locator?: ServiceLocator);
+    /**
+     * @returns {void}
+     * @hidden
+     */
+    renderTable(): void;
+    appendContent(target: HTMLElement, newChild: DocumentFragment, e: NotifyArgs): void;
+}
+/**
+ * VirtualTreeFreezeHdrRenderer is used to render the virtual table within the frozen and movable header table
+ *
+ * @hidden
+ */
+export declare class VirtualTreeFreezeHdrRenderer extends VirtualFreezeHdrRenderer {
+    /**
+     * @returns {void}
+     * @hidden
+     */
+    renderTable(): void;
+    protected rfshMovable(): void;
+}

package/src/treegrid/renderer/virtual-tree-freeze-render.js

@@ -0,0 +1,163 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { ColumnFreezeContentRenderer, FreezeContentRender, FreezeRowModelGenerator, RenderType } from '@syncfusion/ej2-grids';
+import * as literals from '../base/constant';
+import { ColumnVirtualFreezeRenderer, setDebounce, VirtualFreezeHdrRenderer, VirtualFreezeRenderer } from '@syncfusion/ej2-grids';
+import { TreeInterSectionObserver, VirtualTreeContentRenderer } from './virtual-tree-content-render';
+import { getValue } from '@syncfusion/ej2-base';
+/**
+ * VirtualTreeFreezeRenderer is used to render the virtual table within the frozen and movable content table
+ *
+ * @hidden
+ */
+var VirtualTreeFreezeRenderer = /** @class */ (function (_super) {
+    __extends(VirtualTreeFreezeRenderer, _super);
+    function VirtualTreeFreezeRenderer(parent, locator) {
+        var _this = _super.call(this, parent, locator) || this;
+        _this.addEventListener();
+        return _this;
+    }
+    /**
+     * @returns {void}
+     * @hidden
+     */
+    VirtualTreeFreezeRenderer.prototype.renderTable = function () {
+        this.freezeRowGenerator = new FreezeRowModelGenerator(this.parent);
+        this.virtualRenderer = new VirtualTreeContentRenderer(this.parent, this.serviceLoc);
+        this.virtualRenderer.header = this.serviceLoc.getService('rendererFactory')
+            .getRenderer(RenderType.Header).virtualHdrRenderer;
+        FreezeContentRender.prototype.renderTable.call(this);
+        this.virtualRenderer.setPanel(this.parent.getContent());
+        this.scrollbar = this.parent.getContent().querySelector('.e-movablescrollbar');
+        var movableCont = this.getMovableContent();
+        var minHeight = this.parent.height;
+        this.virtualRenderer.virtualEle.content = this.virtualRenderer.content = this.getPanel().querySelector('.' + literals.content);
+        this.virtualRenderer.virtualEle.content.style.overflowX = 'hidden';
+        this.virtualRenderer.virtualEle.renderFrozenWrapper(minHeight);
+        this.virtualRenderer.virtualEle.renderFrozenPlaceHolder();
+        if (this.parent.enableColumnVirtualization) {
+            this.virtualRenderer.virtualEle.movableContent = this.virtualRenderer.movableContent
+                = this.getPanel().querySelector('.' + literals.movableContent);
+            this.virtualRenderer.virtualEle.renderMovableWrapper(minHeight);
+            this.virtualRenderer.virtualEle.renderMovablePlaceHolder();
+            var tbl = movableCont.querySelector('table');
+            this.virtualRenderer.virtualEle.movableTable = tbl;
+            this.virtualRenderer.virtualEle.movableWrapper.appendChild(tbl);
+            movableCont.appendChild(this.virtualRenderer.virtualEle.movableWrapper);
+            movableCont.appendChild(this.virtualRenderer.virtualEle.movablePlaceholder);
+        }
+        this.virtualRenderer.virtualEle.wrapper.appendChild(this.getFrozenContent());
+        this.virtualRenderer.virtualEle.wrapper.appendChild(movableCont);
+        this.virtualRenderer.virtualEle.table = this.getTable();
+        setDebounce(this.parent, this.virtualRenderer, this.scrollbar, this.getMovableContent());
+    };
+    /**
+     * @param {HTMLElement} target - specifies the target
+     * @param {DocumentFragment} newChild - specifies the newChild
+     * @param {NotifyArgs} e - specifies the notifyargs
+     * @returns {void}
+     * @hidden
+     */
+    VirtualTreeFreezeRenderer.prototype.appendContent = function (target, newChild, e) {
+        getValue('observer', this.virtualRenderer).options.debounceEvent = false;
+        this.virtualRenderer['observers'] = new TreeInterSectionObserver(getValue('observer', this.virtualRenderer).element, getValue('observer', this.virtualRenderer).options, getValue('observer', this.virtualRenderer).movableEle);
+        this.virtualRenderer['contents'] = this.getPanel().firstChild;
+        _super.prototype.appendContent.call(this, target, newChild, e);
+    };
+    /**
+     * @param {Object[]} data - specifies the data
+     * @param {NotifyArgs} e - specifies the notifyargs
+     * @returns {Row<Column>[]} returns the row
+     * @hidden
+     */
+    VirtualTreeFreezeRenderer.prototype.generateRows = function (data, e) {
+        return _super.prototype.generateRows.call(this, data, e);
+    };
+    return VirtualTreeFreezeRenderer;
+}(VirtualFreezeRenderer));
+export { VirtualTreeFreezeRenderer };
+/**
+ * ColumnVirtualTreeFreezeRenderer is used to render the virtual table within the frozen and movable content table
+ *
+ * @hidden
+ */
+var ColumnVirtualTreeFreezeRenderer = /** @class */ (function (_super) {
+    __extends(ColumnVirtualTreeFreezeRenderer, _super);
+    function ColumnVirtualTreeFreezeRenderer(parent, locator) {
+        var _this = _super.call(this, parent, locator) || this;
+        _this.serviceLoc = locator;
+        _this.eventListener('on');
+        return _this;
+    }
+    /**
+     * @returns {void}
+     * @hidden
+     */
+    ColumnVirtualTreeFreezeRenderer.prototype.renderTable = function () {
+        this.virtualRenderer = new VirtualTreeContentRenderer(this.parent, this.serviceLoc);
+        this.virtualRenderer.header = this.serviceLoc.getService('rendererFactory')
+            .getRenderer(RenderType.Header).virtualHdrRenderer;
+        this.freezeRowGenerator = new FreezeRowModelGenerator(this.parent);
+        ColumnFreezeContentRenderer.prototype.renderTable.call(this);
+        this.virtualRenderer.setPanel(this.parent.getContent());
+        this.scrollbar = this.parent.getContent().querySelector('.e-movablescrollbar');
+        var frozenRightCont = this.getFrozenRightContent();
+        var frzCont = this.getFrozenContent();
+        var movableCont = this.getMovableContent();
+        if (this.parent.getFrozenMode() === 'Right') {
+            frzCont = frozenRightCont;
+        }
+        this.virtualRenderer.virtualEle.content = this.virtualRenderer.content = this.getPanel().querySelector('.' + literals.content);
+        this.virtualRenderer.virtualEle.content.style.overflowX = 'hidden';
+        var minHeight = this.parent.height;
+        this.virtualRenderer.virtualEle.renderFrozenWrapper(minHeight);
+        this.virtualRenderer.virtualEle.renderFrozenPlaceHolder();
+        _super.prototype['renderVirtualFrozenLeft'].call(this, frzCont, movableCont);
+        _super.prototype['renderVirtualFrozenRight'].call(this, frzCont, movableCont);
+        _super.prototype['renderVirtualFrozenLeftRight'].call(this, frzCont, movableCont, frozenRightCont);
+        this.virtualRenderer.virtualEle.table = this.getTable();
+        setDebounce(this.parent, this.virtualRenderer, this.scrollbar, this.getMovableContent());
+    };
+    ColumnVirtualTreeFreezeRenderer.prototype.appendContent = function (target, newChild, e) {
+        getValue('observer', this.virtualRenderer).options.debounceEvent = false;
+        this.virtualRenderer['observers'] = new TreeInterSectionObserver(getValue('observer', this.virtualRenderer).element, getValue('observer', this.virtualRenderer).options, getValue('observer', this.virtualRenderer).movableEle);
+        this.virtualRenderer['contents'] = this.getPanel().firstChild;
+        _super.prototype.appendContent.call(this, target, newChild, e);
+    };
+    return ColumnVirtualTreeFreezeRenderer;
+}(ColumnVirtualFreezeRenderer));
+export { ColumnVirtualTreeFreezeRenderer };
+/**
+ * VirtualTreeFreezeHdrRenderer is used to render the virtual table within the frozen and movable header table
+ *
+ * @hidden
+ */
+var VirtualTreeFreezeHdrRenderer = /** @class */ (function (_super) {
+    __extends(VirtualTreeFreezeHdrRenderer, _super);
+    function VirtualTreeFreezeHdrRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * @returns {void}
+     * @hidden
+     */
+    VirtualTreeFreezeHdrRenderer.prototype.renderTable = function () {
+        _super.prototype.renderTable.call(this);
+    };
+    VirtualTreeFreezeHdrRenderer.prototype.rfshMovable = function () {
+        _super.prototype.rfshMovable.call(this);
+    };
+    return VirtualTreeFreezeHdrRenderer;
+}(VirtualFreezeHdrRenderer));
+export { VirtualTreeFreezeHdrRenderer };

package/src/treegrid/utils.js

@@ -31,7 +31,7 @@ export function isCountRequired(parent) {
  */
 export function isCheckboxcolumn(parent) {
     for (var i = 0; i < parent.columns.length; i++) {
-        if (parent.columns[i].showCheckbox) {
+        if (parent.columns[parseInt(i.toString(), 10)].showCheckbox) {
             return true;
         }
     }
@@ -59,9 +59,9 @@ export function findParentRecords(records) {
     var datas = [];
     var recordsLength = Object.keys(records).length;
     for (var i = 0, len = recordsLength; i < len; i++) {
-        var hasChild = getObject('hasChildRecords', records[i]);
+        var hasChild = getObject('hasChildRecords', records[parseInt(i.toString(), 10)]);
         if (hasChild) {
-            datas.push(records[i]);
+            datas.push(records[parseInt(i.toString(), 10)]);
         }
     }
     return datas;
@@ -121,13 +121,14 @@ export function findChildrenRecords(records) {
         return [];
     }
     if (!isNullOrUndefined(records.childRecords)) {
-        var childRecords = records.childRecords;
+        var childRecords = records.childRecords.filter(function (item) { return !item.isSummaryRow; });
         var keys = Object.keys(childRecords);
         for (var i = 0, len = keys.length; i < len; i++) {
-            datas.push(childRecords[i]);
-            if (childRecords[i].hasChildRecords || (!isNullOrUndefined(childRecords[i].childRecords) &&
-                childRecords[i].childRecords.length)) {
-                datas = datas.concat(findChildrenRecords(childRecords[i]));
+            datas.push(childRecords[parseInt(i.toString(), 10)]);
+            if (childRecords[parseInt(i.toString(), 10)].hasChildRecords ||
+                (!isNullOrUndefined(childRecords[parseInt(i.toString(), 10)].childRecords) &&
+                    childRecords[parseInt(i.toString(), 10)].childRecords.length)) {
+                datas = datas.concat(findChildrenRecords(childRecords[parseInt(i.toString(), 10)]));
             }
         }
     }
@@ -153,10 +154,10 @@ export function extendArray(array) {
     var obj;
     var keys;
     for (var i = 0; array && i < array.length; i++) {
-        keys = Object.keys(array[i]);
+        keys = Object.keys(array[parseInt(i.toString(), 10)]);
         obj = {};
         for (var j = 0; j < keys.length; j++) {
-            obj[keys[j]] = array[i][keys[j]];
+            obj[keys[parseInt(j.toString(), 10)]] = array[parseInt(i.toString(), 10)][keys[parseInt(j.toString(), 10)]];
         }
         objArr.push(obj);
     }
@@ -185,11 +186,11 @@ export function getPlainData(value) {
 export function getParentData(parent, value, requireFilter) {
     if (requireFilter) {
         var idFilter = 'uniqueIDFilterCollection';
-        return parent[idFilter][value];
+        return parent["" + idFilter]["" + value];
     }
     else {
         var id = 'uniqueIDCollection';
-        return parent[id][value];
+        return parent["" + id]["" + value];
     }
 }
 /**