@visactor/vtable 0.9.0-alpha.0-alpha.0

package/es/layout/pivot-header-layout.js

@@ -0,0 +1,888 @@
+import { cloneDeep, isValid, transpose } from "../tools/util";
+
+import { HierarchyState } from "../ts-types";
+
+import { NumberMap } from "../tools/NumberMap";
+
+import { IndicatorDimensionKeyPlaceholder } from "../tools/global";
+
+class DimensionTree {
+    constructor(tree, hierarchyType = "grid", rowExpandLevel = void 0) {
+        this.sizeIncludeParent = !1, this.tree = {
+            id: 0,
+            dimensionKey: "",
+            value: "",
+            children: [],
+            level: -1,
+            startIndex: 0,
+            size: 0,
+            startInTotal: 0,
+            hierarchyState: void 0
+        }, this.totalLevel = 0, this.dimensionKeys = new NumberMap, this.sizeIncludeParent = null != rowExpandLevel, 
+        this.rowExpandLevel = rowExpandLevel, this.hierarchyType = hierarchyType, this.reset(tree);
+    }
+    reset(tree, updateTreeNode = !1) {
+        this.dimensionKeys = new NumberMap, this.tree.children = tree, this.setTreeNode(this.tree, 0, this.tree), 
+        this.totalLevel = this.dimensionKeys.count();
+    }
+    setTreeNode(node, startIndex, parent) {
+        var _a, _b;
+        node.startIndex = startIndex, node.startInTotal = (null !== (_a = parent.startInTotal) && void 0 !== _a ? _a : 0) + node.startIndex, 
+        (null !== (_b = node.dimensionKey) && void 0 !== _b ? _b : node.indicatorKey) && (!this.dimensionKeys.contain(node.indicatorKey ? IndicatorDimensionKeyPlaceholder : node.dimensionKey) && this.dimensionKeys.put(node.level, node.indicatorKey ? IndicatorDimensionKeyPlaceholder : node.dimensionKey), 
+        node.id || (node.id = ++seqId));
+        let size = node.dimensionKey && this.sizeIncludeParent ? 1 : 0;
+        return "grid" === this.hierarchyType ? node.children ? node.children.forEach((n => {
+            var _a;
+            n.level = (null !== (_a = node.level) && void 0 !== _a ? _a : 0) + 1, size += this.setTreeNode(n, size, node);
+        })) : size = 1 : node.hierarchyState === HierarchyState.expand && node.children ? node.children.forEach((n => {
+            var _a;
+            n.level = (null !== (_a = node.level) && void 0 !== _a ? _a : 0) + 1, size += this.setTreeNode(n, size, node);
+        })) : node.hierarchyState === HierarchyState.collapse && node.children ? node.children.forEach((n => {
+            var _a;
+            n.level = (null !== (_a = node.level) && void 0 !== _a ? _a : 0) + 1, this.setTreeNode(n, size, node);
+        })) : !node.hierarchyState && node.level + 1 < this.rowExpandLevel && node.children ? (node.hierarchyState = HierarchyState.expand, 
+        node.children.forEach((n => {
+            var _a;
+            n.level = (null !== (_a = node.level) && void 0 !== _a ? _a : 0) + 1, size += this.setTreeNode(n, size, node);
+        }))) : node.children ? (node.hierarchyState = HierarchyState.collapse, node.children.forEach((n => {
+            var _a;
+            n.level = (null !== (_a = node.level) && void 0 !== _a ? _a : 0) + 1, this.setTreeNode(n, size, node);
+        }))) : (node.hierarchyState = HierarchyState.none, size = 1), node.size = size, 
+        size;
+    }
+    getTreePath(index, maxDeep = 30) {
+        const path = [];
+        return this.searchPath(index, this.tree, path, maxDeep), path.shift(), path;
+    }
+    searchPath(index, node, path, maxDeep) {
+        if (!node) return !1;
+        if (index < node.startIndex || index >= node.startIndex + node.size) return !1;
+        if (path.push(node), !node.children || 0 === node.children.length) return !0;
+        if (node.level >= maxDeep) return !0;
+        const cIndex = index - node.startIndex;
+        return node.children.some((n => this.searchPath(cIndex, n, path, maxDeep))), !0;
+    }
+    movePosition(level, sourceIndex, targetIndex) {
+        let parNode, sourceSubIndex, targetSubIndex;
+        const findTargetNode = (node, subIndex) => {
+            if ((void 0 === sourceSubIndex || void 0 === targetSubIndex) && (node.level === level && (node.startInTotal === sourceIndex && (sourceSubIndex = subIndex), 
+            node.startInTotal <= targetIndex && targetIndex <= node.startInTotal + node.size - 1 && (targetSubIndex = subIndex)), 
+            node.children && node.level < level)) {
+                parNode = node;
+                for (let i = 0; i < node.children.length; i++) (sourceIndex >= node.children[i].startInTotal && sourceIndex <= node.children[i].startInTotal + node.children[i].size || targetIndex >= node.children[i].startInTotal && targetIndex <= node.children[i].startInTotal + node.children[i].size) && findTargetNode(node.children[i], i);
+            }
+        };
+        findTargetNode(this.tree, 0);
+        const sourceColumns = parNode.children.splice(sourceSubIndex, 1);
+        sourceColumns.unshift(targetSubIndex, 0), Array.prototype.splice.apply(parNode.children, sourceColumns);
+    }
+}
+
+let seqId = 0, colIndex = 0;
+
+export class PivotHeaderLayoutMap {
+    constructor(table) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        if (this._showHeader = !0, this.columnHeaderObjs = [], this.rowHeaderObjs = [], 
+        this._cornerHeaderCellIds = [], this._columnHeaderCellIds = [], this._rowHeaderCellIds = [], 
+        this._columnWidths = [], this.columnPaths = [], this._headerObjects = [], this._headerObjectMap = {}, 
+        this._indicators = [], this.indicatorsAsCol = !0, this.hideIndicatorName = !1, this._showRowHeader = !0, 
+        this._showColumnHeader = !0, this._indicatorShowType = "column", this.rowDimensionKeys = [], 
+        this.colDimensionKeys = [], this.indicatorKeys = [], this.indicatorDimensionKey = IndicatorDimensionKeyPlaceholder, 
+        this._table = table, this._cellRangeMap = new Map, this._CellHeaderPathMap = new Map, 
+        this.rowTree = table.options.rowTree, this.columnTree = table.options.columnTree, 
+        this.rowsDefine = null !== (_a = table.options.rows) && void 0 !== _a ? _a : [], 
+        this.columnsDefine = null !== (_b = table.options.columns) && void 0 !== _b ? _b : [], 
+        this.indicatorsDefine = null !== (_c = table.options.indicators) && void 0 !== _c ? _c : [], 
+        this.indicatorTitle = table.options.indicatorTitle, this.hideIndicatorName = null !== (_d = table.options.hideIndicatorName) && void 0 !== _d && _d, 
+        this.showRowHeader = null === (_e = table.options.showRowHeader) || void 0 === _e || _e, 
+        this.showColumnHeader = null === (_f = table.options.showColumnHeader) || void 0 === _f || _f, 
+        this.rowHeaderTitle = table.options.rowHeaderTitle, this.columnHeaderTitle = table.options.columnHeaderTitle, 
+        this.rowHierarchyType = null !== (_g = table.options.rowHierarchyType) && void 0 !== _g ? _g : "grid", 
+        this.rowExpandLevel = null !== (_h = table.options.rowExpandLevel) && void 0 !== _h ? _h : 1, 
+        this.rowHierarchyIndent = null !== (_j = table.options.rowHierarchyIndent) && void 0 !== _j ? _j : 20, 
+        this.cornerSetting = null !== (_k = table.options.corner) && void 0 !== _k ? _k : {
+            titleOnDimension: "column"
+        }, null === (_l = this.indicatorsDefine) || void 0 === _l || _l.forEach((indicator => {
+            "string" == typeof indicator ? this.indicatorKeys.push(indicator) : this.indicatorKeys.push(indicator.indicatorKey);
+        })), this.columnDimensionTree = new DimensionTree(null !== (_m = this.columnTree) && void 0 !== _m ? _m : []), 
+        this.rowDimensionTree = new DimensionTree(null !== (_o = this.rowTree) && void 0 !== _o ? _o : [], this.rowHierarchyType, "tree" === this.rowHierarchyType ? this.rowExpandLevel : void 0), 
+        this.colDimensionKeys = this.columnDimensionTree.dimensionKeys.valueArr(), this.rowDimensionKeys = this.rowDimensionTree.dimensionKeys.valueArr(), 
+        this.cornerHeaderObjs = "column" === this.cornerSetting.titleOnDimension ? this._addCornerHeaders(this.columnHeaderTitle ? [ "" ].concat(this.colDimensionKeys) : this.colDimensionKeys) : "row" === this.cornerSetting.titleOnDimension ? this._addCornerHeaders(this.rowHeaderTitle ? [ "" ].concat(this.rowDimensionKeys) : this.rowDimensionKeys) : this._addCornerHeaders(null), 
+        this.columnDimensionTree.tree.children && (this.columnHeaderObjs = this._addHeaders(this._columnHeaderCellIds, 0, this.columnDimensionTree.tree.children, []), 
+        this.columnHeaderTitle)) {
+            const id = ++seqId, firstRowIds = Array(this.colCount - this.rowHeaderLevelCount).fill(id);
+            this._columnHeaderCellIds.unshift(firstRowIds);
+            const cell = {
+                id: id,
+                caption: "string" == typeof this.columnHeaderTitle.title ? this.columnHeaderTitle.title : this.columnsDefine.reduce(((title, value) => "string" == typeof value ? title : title + (title ? `/${value.dimensionTitle}` : `${value.dimensionTitle}`)), ""),
+                field: void 0,
+                headerType: null !== (_p = this.columnHeaderTitle.headerType) && void 0 !== _p ? _p : "text",
+                style: this.columnHeaderTitle.headerStyle,
+                define: {
+                    id: id
+                }
+            };
+            this.columnHeaderObjs.push(cell), this._headerObjects[id] = cell;
+        }
+        if (colIndex = 0, this.rowDimensionTree.tree.children && (this.rowHeaderObjs = "tree" === this.rowHierarchyType ? this._addHeadersForTreeMode(this._rowHeaderCellIds, 0, this.rowDimensionTree.tree.children, [], this.rowDimensionTree.totalLevel, !0) : this._addHeaders(this._rowHeaderCellIds, 0, this.rowDimensionTree.tree.children, [])), 
+        this.rowHeaderTitle) {
+            const id = ++seqId, firstColIds = Array(this.rowCount - this.columnHeaderLevelCount).fill(id);
+            this._rowHeaderCellIds.unshift(firstColIds);
+            const cell = {
+                id: id,
+                caption: "string" == typeof this.rowHeaderTitle.title ? this.rowHeaderTitle.title : this.rowsDefine.reduce(((title, value) => "string" == typeof value ? title : title + (title ? `/${value.dimensionTitle}` : `${value.dimensionTitle}`)), ""),
+                field: void 0,
+                headerType: null !== (_q = this.rowHeaderTitle.headerType) && void 0 !== _q ? _q : "text",
+                style: this.rowHeaderTitle.headerStyle,
+                define: {
+                    id: id
+                }
+            };
+            this.rowHeaderObjs.push(cell), this._headerObjects[id] = cell;
+        }
+        colIndex = 0, this.indicatorsAsCol = !isValid(this.rowDimensionKeys.find((key => key === this.indicatorDimensionKey))), 
+        this._rowHeaderCellIds = transpose(this._rowHeaderCellIds), this._headerObjectMap = this._headerObjects.reduce(((o, e) => (o[e.id] = e, 
+        o)), {}), this.indicatorsAsCol && !this.hideIndicatorName ? this._indicatorShowType = "column" : this.indicatorsAsCol || this.hideIndicatorName ? this._indicatorShowType = "none" : this._indicatorShowType = "row", 
+        this.setColumnWidths();
+    }
+    _addHeaders(_headerCellIds, row, header, roots) {
+        const results = [];
+        return _headerCellIds[row] || function(row) {
+            const newRow = _headerCellIds[row] = [];
+            if (0 === colIndex) return newRow;
+            const prev = _headerCellIds[row - 1];
+            for (let col = 0; col < (null == prev ? void 0 : prev.length); col++) newRow[col] = prev[col];
+        }(row), header.forEach((hd => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+            const id = hd.id, dimensionInfo = null !== (_b = null === (_a = this.rowsDefine) || void 0 === _a ? void 0 : _a.find((dimension => "string" != typeof dimension && dimension.dimensionKey === hd.dimensionKey))) && void 0 !== _b ? _b : null === (_c = this.columnsDefine) || void 0 === _c ? void 0 : _c.find((dimension => "string" != typeof dimension && dimension.dimensionKey === hd.dimensionKey)), indicatorInfo = null === (_d = this.indicatorsDefine) || void 0 === _d ? void 0 : _d.find((indicator => "string" != typeof indicator && (hd.indicatorKey ? indicator.indicatorKey === hd.indicatorKey : indicator.caption === hd.value))), cell = {
+                id: id,
+                caption: null !== (_e = hd.value) && void 0 !== _e ? _e : indicatorInfo.caption,
+                field: hd.dimensionKey,
+                style: "function" == typeof (null === (_f = null != indicatorInfo ? indicatorInfo : dimensionInfo) || void 0 === _f ? void 0 : _f.headerStyle) ? null === (_g = null != indicatorInfo ? indicatorInfo : dimensionInfo) || void 0 === _g ? void 0 : _g.headerStyle : Object.assign({}, null === (_h = null != indicatorInfo ? indicatorInfo : dimensionInfo) || void 0 === _h ? void 0 : _h.headerStyle),
+                headerType: null !== (_k = null !== (_j = null == indicatorInfo ? void 0 : indicatorInfo.headerType) && void 0 !== _j ? _j : null == dimensionInfo ? void 0 : dimensionInfo.headerType) && void 0 !== _k ? _k : "text",
+                headerIcon: null !== (_l = null == indicatorInfo ? void 0 : indicatorInfo.headerIcon) && void 0 !== _l ? _l : null == dimensionInfo ? void 0 : dimensionInfo.headerIcon,
+                define: Object.assign({}, hd, null != indicatorInfo ? indicatorInfo : dimensionInfo),
+                fieldFormat: null !== (_m = null == indicatorInfo ? void 0 : indicatorInfo.headerFormat) && void 0 !== _m ? _m : null == dimensionInfo ? void 0 : dimensionInfo.headerFormat,
+                dropDownMenu: null !== (_o = null == indicatorInfo ? void 0 : indicatorInfo.dropDownMenu) && void 0 !== _o ? _o : null == dimensionInfo ? void 0 : dimensionInfo.dropDownMenu,
+                pivotInfo: {
+                    value: hd.value,
+                    dimensionKey: hd.dimensionKey,
+                    isPivotCorner: !1
+                },
+                width: null == dimensionInfo ? void 0 : dimensionInfo.width,
+                minWidth: null == dimensionInfo ? void 0 : dimensionInfo.minWidth,
+                maxWidth: null == dimensionInfo ? void 0 : dimensionInfo.maxWidth,
+                showSort: null !== (_p = null == indicatorInfo ? void 0 : indicatorInfo.showSort) && void 0 !== _p ? _p : null == dimensionInfo ? void 0 : dimensionInfo.showSort,
+                description: null == dimensionInfo ? void 0 : dimensionInfo.description
+            };
+            indicatorInfo ? (indicatorInfo.customRender && (hd.customRender = indicatorInfo.customRender), 
+            isValid(this._indicators.find((indicator => indicator.indicatorKey === indicatorInfo.indicatorKey))) || this._indicators.push({
+                id: ++seqId,
+                indicatorKey: indicatorInfo.indicatorKey,
+                field: indicatorInfo.indicatorKey,
+                fieldFormat: null == indicatorInfo ? void 0 : indicatorInfo.format,
+                columnType: null !== (_q = null == indicatorInfo ? void 0 : indicatorInfo.columnType) && void 0 !== _q ? _q : "text",
+                chartType: "chartType" in indicatorInfo ? indicatorInfo.chartType : null,
+                chartSpec: "chartSpec" in indicatorInfo ? indicatorInfo.chartSpec : null,
+                sparklineSpec: "sparklineSpec" in indicatorInfo ? indicatorInfo.sparklineSpec : null,
+                style: null == indicatorInfo ? void 0 : indicatorInfo.style,
+                icon: null == indicatorInfo ? void 0 : indicatorInfo.icon,
+                define: Object.assign({}, hd, indicatorInfo, {
+                    dragHeader: null == dimensionInfo ? void 0 : dimensionInfo.dragHeader
+                }),
+                width: null == indicatorInfo ? void 0 : indicatorInfo.width,
+                minWidth: null == indicatorInfo ? void 0 : indicatorInfo.minWidth,
+                maxWidth: null == indicatorInfo ? void 0 : indicatorInfo.maxWidth,
+                disableColumnResize: null == indicatorInfo ? void 0 : indicatorInfo.disableColumnResize
+            })) : hd.indicatorKey && (isValid(this._indicators.find((indicator => indicator.indicatorKey === hd.indicatorKey))) || this._indicators.push({
+                id: ++seqId,
+                indicatorKey: hd.indicatorKey,
+                field: hd.indicatorKey,
+                columnType: "text",
+                define: Object.assign({}, hd)
+            })), results[id] = cell, this._headerObjects[id] = cell, _headerCellIds[row][colIndex] = id;
+            for (let r = row - 1; r >= 0; r--) _headerCellIds[r][colIndex] = roots[r];
+            if (hd.children) this._addHeaders(_headerCellIds, row + 1, null !== (_r = hd.children) && void 0 !== _r ? _r : [], [ ...roots, id ]).forEach((c => results.push(c))); else {
+                for (let r = row + 1; r < _headerCellIds.length; r++) _headerCellIds[r][colIndex] = id;
+                colIndex++;
+            }
+        })), results;
+    }
+    _addHeadersForTreeMode(_headerCellIds, row, header, roots, totalLevel, show) {
+        const results = [];
+        return _headerCellIds[row] || function(row) {
+            const newRow = _headerCellIds[row] = [];
+            if (0 === colIndex) return newRow;
+            const prev = _headerCellIds[row - 1];
+            for (let col = 0; col < (null == prev ? void 0 : prev.length); col++) newRow[col] = prev[col];
+        }(row), header.forEach((hd => {
+            var _a, _b, _c, _d, _e;
+            const id = hd.id, dimensionInfo = null !== (_b = null === (_a = this.rowsDefine) || void 0 === _a ? void 0 : _a.find((dimension => "string" != typeof dimension && dimension.dimensionKey === hd.dimensionKey))) && void 0 !== _b ? _b : null === (_c = this.columnsDefine) || void 0 === _c ? void 0 : _c.find((dimension => "string" != typeof dimension && dimension.dimensionKey === hd.dimensionKey)), cell = {
+                id: id,
+                caption: hd.value,
+                field: hd.dimensionKey,
+                style: hd.level + 1 === totalLevel || "function" == typeof (null == dimensionInfo ? void 0 : dimensionInfo.headerStyle) ? null == dimensionInfo ? void 0 : dimensionInfo.headerStyle : Object.assign({}, null == dimensionInfo ? void 0 : dimensionInfo.headerStyle, {
+                    textAlign: "left"
+                }),
+                headerType: null !== (_d = null == dimensionInfo ? void 0 : dimensionInfo.headerType) && void 0 !== _d ? _d : "text",
+                headerIcon: null == dimensionInfo ? void 0 : dimensionInfo.headerIcon,
+                define: Object.assign(hd, {
+                    linkJump: "linkJump" in dimensionInfo ? dimensionInfo.linkJump : null,
+                    linkDetect: "linkDetect" in dimensionInfo ? dimensionInfo.linkDetect : null,
+                    templateLink: "templateLink" in dimensionInfo ? dimensionInfo.templateLink : null,
+                    keepAspectRatio: "keepAspectRatio" in dimensionInfo && dimensionInfo.keepAspectRatio,
+                    imageAutoSizing: "imageAutoSizing" in dimensionInfo ? dimensionInfo.imageAutoSizing : null,
+                    headerCustomRender: null == dimensionInfo ? void 0 : dimensionInfo.headerCustomRender,
+                    headerCustomLayout: null == dimensionInfo ? void 0 : dimensionInfo.headerCustomLayout,
+                    dragHeader: null == dimensionInfo ? void 0 : dimensionInfo.dragHeader
+                }),
+                fieldFormat: null == dimensionInfo ? void 0 : dimensionInfo.headerFormat,
+                dropDownMenu: null == dimensionInfo ? void 0 : dimensionInfo.dropDownMenu,
+                pivotInfo: {
+                    value: hd.value,
+                    dimensionKey: hd.dimensionKey,
+                    isPivotCorner: !1
+                },
+                hierarchyLevel: hd.level,
+                dimensionTotalLevel: totalLevel,
+                hierarchyState: hd.level + 1 === totalLevel ? void 0 : hd.hierarchyState,
+                width: null == dimensionInfo ? void 0 : dimensionInfo.width,
+                minWidth: null == dimensionInfo ? void 0 : dimensionInfo.minWidth,
+                maxWidth: null == dimensionInfo ? void 0 : dimensionInfo.maxWidth
+            };
+            results[id] = cell, this._headerObjects[id] = cell, _headerCellIds[row][colIndex] = id;
+            for (let r = row - 1; r >= 0; r--) _headerCellIds[r][colIndex] = roots[r];
+            if (hd.hierarchyState === HierarchyState.expand && hd.children) show && colIndex++, 
+            this._addHeadersForTreeMode(_headerCellIds, row, null !== (_e = hd.children) && void 0 !== _e ? _e : [], [ ...roots, id ], totalLevel, show && hd.hierarchyState === HierarchyState.expand).forEach((c => results.push(c))); else {
+                show && colIndex++;
+                for (let r = row + 1; r < _headerCellIds.length; r++) _headerCellIds[r][colIndex] = id;
+            }
+        })), results;
+    }
+    _addCornerHeaders(dimensionKeys) {
+        var _a;
+        const results = [];
+        if (dimensionKeys) dimensionKeys.forEach(((dimensionKey, key) => {
+            var _a, _b, _c, _d, _e, _f;
+            const id = ++seqId, dimensionInfo = null !== (_b = null === (_a = this.rowsDefine) || void 0 === _a ? void 0 : _a.find((dimension => "string" != typeof dimension && dimension.dimensionKey === dimensionKey))) && void 0 !== _b ? _b : null === (_c = this.columnsDefine) || void 0 === _c ? void 0 : _c.find((dimension => "string" != typeof dimension && dimension.dimensionKey === dimensionKey)), cell = {
+                id: id,
+                caption: dimensionKey === this.indicatorDimensionKey ? this.indicatorTitle : null !== (_d = null == dimensionInfo ? void 0 : dimensionInfo.dimensionTitle) && void 0 !== _d ? _d : "",
+                field: "维度名称",
+                style: this.cornerSetting.headerStyle,
+                headerType: null !== (_e = this.cornerSetting.headerType) && void 0 !== _e ? _e : "text",
+                define: {
+                    dimensionKey: "维度名称",
+                    id: id,
+                    value: dimensionKey
+                },
+                dropDownMenu: null == dimensionInfo ? void 0 : dimensionInfo.cornerDropDownMenu,
+                pivotInfo: {
+                    value: null !== (_f = null == dimensionInfo ? void 0 : dimensionInfo.dimensionTitle) && void 0 !== _f ? _f : "",
+                    dimensionKey: dimensionKey,
+                    isPivotCorner: !0
+                },
+                description: null == dimensionInfo ? void 0 : dimensionInfo.cornerDescription
+            };
+            if (results[id] = cell, this._headerObjects[id] = cell, "column" === this.cornerSetting.titleOnDimension) {
+                this._cornerHeaderCellIds[key] || (this._cornerHeaderCellIds[key] = []);
+                for (let r = 0; r < this.rowHeaderLevelCount; r++) this._cornerHeaderCellIds[key][r] = id;
+            } else if ("row" === this.cornerSetting.titleOnDimension) for (let r = 0; r < this.columnHeaderLevelCount; r++) this._cornerHeaderCellIds[r] || (this._cornerHeaderCellIds[r] = []), 
+            this._cornerHeaderCellIds[r][key] = id;
+        })); else {
+            const id = ++seqId, cell = {
+                id: id,
+                caption: "",
+                field: "维度名称",
+                style: this.cornerSetting.headerStyle,
+                headerType: null !== (_a = this.cornerSetting.headerType) && void 0 !== _a ? _a : "text",
+                define: {
+                    dimensionKey: "维度名称",
+                    id: id,
+                    value: ""
+                }
+            };
+            results[id] = cell, this._headerObjects[id] = cell;
+            for (let r = 0; r < this.columnHeaderLevelCount; r++) for (let j = 0; j < this.rowHeaderLevelCount; j++) this._cornerHeaderCellIds[r] || (this._cornerHeaderCellIds[r] = []), 
+            this._cornerHeaderCellIds[r][j] = id;
+        }
+        return results;
+    }
+    get columnWidths() {
+        return this._columnWidths;
+    }
+    setColumnWidths() {
+        const returnWidths = new Array(this.colCount).fill(void 0);
+        if (this.showHeader && this.showRowHeader && (this.rowHeaderTitle && (returnWidths[0] = {}), 
+        this.rowDimensionKeys.forEach(((objKey, index) => {
+            var _a;
+            const dimension = null === (_a = this.rowsDefine) || void 0 === _a ? void 0 : _a.find((dimension => "string" != typeof dimension && dimension.dimensionKey === objKey));
+            dimension && (returnWidths[index + (this.rowHeaderTitle ? 1 : 0)] = {
+                width: dimension.width,
+                minWidth: dimension.minWidth,
+                maxWidth: dimension.maxWidth
+            });
+        }))), this.indicatorsAsCol) for (let i = this.rowHeaderLevelCount; i < this.colCount; i++) {
+            const cellDefine = this.getBody(i, this.columnHeaderLevelCount);
+            returnWidths[i] = {
+                width: null == cellDefine ? void 0 : cellDefine.width,
+                minWidth: null == cellDefine ? void 0 : cellDefine.minWidth,
+                maxWidth: null == cellDefine ? void 0 : cellDefine.maxWidth
+            };
+        } else {
+            let maxWidth, minWidth, isAuto, width = 0;
+            this._indicators.forEach(((obj, index) => {
+                "number" == typeof obj.width ? width = Math.max(obj.width, width) : "auto" === obj.width && (isAuto = !0), 
+                "number" == typeof obj.minWidth && (minWidth = Math.max(obj.minWidth, minWidth)), 
+                "number" == typeof obj.maxWidth && (maxWidth = Math.max(obj.maxWidth, maxWidth));
+            })), width = width > 0 ? width : isAuto ? "auto" : void 0, returnWidths.fill({
+                width: width,
+                minWidth: minWidth,
+                maxWidth: maxWidth
+            }, this.rowHeaderLevelCount, this.colCount);
+        }
+        this._columnWidths = returnWidths;
+    }
+    get showHeader() {
+        return this._showHeader;
+    }
+    set showHeader(_showHeader) {
+        this._showHeader = _showHeader;
+    }
+    get showColumnHeader() {
+        return this._showColumnHeader;
+    }
+    set showColumnHeader(_showColumnHeader) {
+        this._showColumnHeader = _showColumnHeader;
+    }
+    get showRowHeader() {
+        return this._showRowHeader;
+    }
+    set showRowHeader(_showRowHeader) {
+        this._showRowHeader = _showRowHeader;
+    }
+    get columnHeaderTitle() {
+        return this._columnHeaderTitle;
+    }
+    set columnHeaderTitle(_columnHeaderTitle) {
+        this._columnHeaderTitle = _columnHeaderTitle;
+    }
+    get rowHeaderTitle() {
+        return this._rowHeaderTitle;
+    }
+    set rowHeaderTitle(_rowHeaderTitle) {
+        this._rowHeaderTitle = _rowHeaderTitle;
+    }
+    getHeaderFieldKey(col, row) {}
+    getCellType(col, row) {
+        return this.isCornerHeader(col, row) ? "cornerHeader" : this.isColumnHeader(col, row) ? "columnHeader" : this.isRowHeader(col, row) ? "rowHeader" : "body";
+    }
+    isHeader(col, row) {
+        return col < this.rowHeaderLevelCount || row < this.columnHeaderLevelCount;
+    }
+    isCornerHeader(col, row) {
+        return col < this.rowHeaderLevelCount && row < this.columnHeaderLevelCount;
+    }
+    isColumnHeader(col, row) {
+        return col >= this.rowHeaderLevelCount && row < this.columnHeaderLevelCount;
+    }
+    isRowHeader(col, row) {
+        return col < this.rowHeaderLevelCount && row >= this.columnHeaderLevelCount;
+    }
+    getColumnHeaderRange() {
+        return {
+            start: {
+                col: this.rowHeaderLevelCount,
+                row: 0
+            },
+            end: {
+                col: this.colCount - 1,
+                row: this.columnHeaderLevelCount - 1
+            }
+        };
+    }
+    getRowHeaderRange() {
+        return {
+            start: {
+                col: 0,
+                row: this.columnHeaderLevelCount
+            },
+            end: {
+                col: this.rowHeaderLevelCount - 1,
+                row: this.rowCount - 1
+            }
+        };
+    }
+    getCornerHeaderRange() {
+        return {
+            start: {
+                col: 0,
+                row: 0
+            },
+            end: {
+                col: this.rowHeaderLevelCount - 1,
+                row: this.columnHeaderLevelCount - 1
+            }
+        };
+    }
+    getBodyRange() {
+        return {
+            start: {
+                col: this.rowHeaderLevelCount,
+                row: this.columnHeaderLevelCount
+            },
+            end: {
+                col: this.colCount - 1,
+                row: this.rowCount - 1
+            }
+        };
+    }
+    resetCellIds() {}
+    get headerLevelCount() {
+        return this.columnHeaderLevelCount;
+    }
+    get columnHeaderLevelCount() {
+        if (this.showHeader && this.showColumnHeader) {
+            let count = this.indicatorsAsCol && this.hideIndicatorName && this.colDimensionKeys[this.colDimensionKeys.length - 1] === this.indicatorDimensionKey ? this.columnDimensionTree.totalLevel - 1 : this.columnDimensionTree.totalLevel;
+            return this.columnHeaderTitle && (count += 1), count;
+        }
+        return 0;
+    }
+    get rowHeaderLevelCount() {
+        if (this.showHeader && this.showRowHeader) {
+            if ("tree" === this.rowHierarchyType) return this.rowHeaderTitle ? 2 : 1;
+            let count = this.indicatorsAsCol ? this.rowDimensionTree.totalLevel : this.hideIndicatorName && this.rowDimensionKeys[this.rowDimensionKeys.length - 1] === this.indicatorDimensionKey ? this.rowDimensionTree.totalLevel - 1 : this.rowDimensionTree.totalLevel;
+            return this.rowHeaderTitle && (count += 1), count;
+        }
+        return 0;
+    }
+    get colCount() {
+        return this.columnDimensionTree.tree.size + this.rowHeaderLevelCount;
+    }
+    get rowCount() {
+        return this.rowDimensionTree.tree.size + this.columnHeaderLevelCount;
+    }
+    get bodyRowCount() {
+        return this.rowDimensionTree.tree.size;
+    }
+    get headerObjects() {
+        return this._headerObjects;
+    }
+    get columnObjects() {
+        return this._indicators;
+    }
+    getCellId(col, row) {
+        var _a;
+        if (row >= 0 && col >= 0) {
+            if (this.isCornerHeader(col, row)) return this._cornerHeaderCellIds[row][col];
+            if (this.isColumnHeader(col, row)) return this._columnHeaderCellIds[row][col - this.rowHeaderLevelCount];
+            if (this.isRowHeader(col, row)) return null === (_a = this._rowHeaderCellIds[row - this.columnHeaderLevelCount]) || void 0 === _a ? void 0 : _a[col];
+        }
+    }
+    getHeader(col, row) {
+        const id = this.getCellId(col, row);
+        return this._headerObjectMap[id];
+    }
+    getHeaderField(col, row) {
+        var _a, _b;
+        const id = this.getCellId(col, row);
+        return (null === (_a = this._headerObjectMap[id]) || void 0 === _a ? void 0 : _a.field) || (null === (_b = this.getBody(col, row)) || void 0 === _b ? void 0 : _b.field);
+    }
+    getHeaderCellAdress(id) {
+        for (let i = 0; i < this._columnHeaderCellIds.length; i++) {
+            const row = this._columnHeaderCellIds[i];
+            for (let j = 0; j < row.length; j++) if (row[j] === id) return {
+                col: j,
+                row: i
+            };
+        }
+        for (let i = 0; i < this._rowHeaderCellIds.length; i++) {
+            const row = this._rowHeaderCellIds[i];
+            for (let j = 0; j < row.length; j++) if (row[j] === id) return {
+                col: j,
+                row: i
+            };
+        }
+        for (let i = 0; i < this._cornerHeaderCellIds.length; i++) {
+            const row = this._cornerHeaderCellIds[i];
+            for (let j = 0; j < row.length; j++) if (row[j] === id) return {
+                col: j,
+                row: i
+            };
+        }
+    }
+    getHeaderCellAddressByField(field) {
+        const hd = this.headerObjects.find((col => col && col.field === field));
+        return this.getHeaderCellAdress(hd.id);
+    }
+    getBody(_col, _row) {
+        var _a, _b, _c, _d, _e, _f;
+        const paths = this.getCellHeaderPaths(_col, _row);
+        if (this.indicatorsAsCol) {
+            const indicatorKey = null === (_a = paths.colHeaderPaths.find((colPath => colPath.indicatorKey))) || void 0 === _a ? void 0 : _a.indicatorKey;
+            return null !== (_c = null !== (_b = this._indicators.find((indicator => indicator.indicatorKey === indicatorKey))) && void 0 !== _b ? _b : this._indicators[0]) && void 0 !== _c ? _c : {
+                id: "",
+                field: void 0,
+                indicatorKey: void 0,
+                columnType: void 0,
+                define: void 0
+            };
+        }
+        const indicatorKey = null === (_d = paths.rowHeaderPaths.find((rowPath => rowPath.indicatorKey))) || void 0 === _d ? void 0 : _d.indicatorKey;
+        return null !== (_f = null !== (_e = this._indicators.find((indicator => indicator.indicatorKey === indicatorKey))) && void 0 !== _e ? _e : this._indicators[0]) && void 0 !== _f ? _f : {
+            id: "",
+            field: void 0,
+            indicatorKey: void 0,
+            columnType: void 0,
+            define: void 0
+        };
+    }
+    getBodyLayoutRangeById(id) {
+        var _a;
+        for (let col = 0; col < (null !== (_a = this.colCount) && void 0 !== _a ? _a : 0); col++) if (id === this.columnObjects[col].id) return {
+            start: {
+                col: col,
+                row: 0
+            },
+            end: {
+                col: col,
+                row: 0
+            }
+        };
+        throw new Error(`can not found body layout @id=${id}`);
+    }
+    getCellRange(col, row) {
+        var _a, _b;
+        if (-1 === col || -1 === row) return {
+            start: {
+                col: col,
+                row: row
+            },
+            end: {
+                col: col,
+                row: row
+            }
+        };
+        if (this._cellRangeMap.has(`${col}-${row}`)) return this._cellRangeMap.get(`${col}-${row}`);
+        const result = {
+            start: {
+                col: col,
+                row: row
+            },
+            end: {
+                col: col,
+                row: row
+            }
+        };
+        if (this.isHeader(col, row) && -1 !== col && -1 !== row) {
+            const id = this.getCellId(col, row);
+            for (let c = col - 1; c >= 0 && id === this.getCellId(c, row); c--) result.start.col = c;
+            for (let c = col + 1; c < (null !== (_a = this.colCount) && void 0 !== _a ? _a : 0) && id === this.getCellId(c, row); c++) result.end.col = c;
+            for (let r = row - 1; r >= 0 && id === this.getCellId(col, r); r--) result.start.row = r;
+            for (let r = row + 1; r < (null !== (_b = this.rowCount) && void 0 !== _b ? _b : 0) && id === this.getCellId(col, r); r++) result.end.row = r;
+        }
+        return this._cellRangeMap.set(`${col}-${row}`, result), result;
+    }
+    isCellRangeEqual(col, row, targetCol, targetRow) {
+        const range1 = this.getCellRange(col, row), range2 = this.getCellRange(targetCol, targetRow);
+        return range1.start.col === range2.start.col && range1.end.col === range2.end.col && range1.start.row === range2.start.row && range1.end.row === range2.end.row;
+    }
+    getRecordIndexByRow(row) {
+        return row < this.columnHeaderLevelCount ? -1 : row - this.columnHeaderLevelCount;
+    }
+    getRecordIndexByCol(col) {
+        return col < this.rowHeaderLevelCount ? -1 : col - this.rowHeaderLevelCount;
+    }
+    getRecordStartRowByRecordIndex(index) {
+        return this.columnHeaderLevelCount + index;
+    }
+    getCellHeaderPathsWidthTreeNode(col, row) {
+        if (this._CellHeaderPathMap.has(`${col}-${row}`)) return this._CellHeaderPathMap.get(`${col}-${row}`);
+        const recordCol = this.getRecordIndexByCol(col), recordRow = this.getRecordIndexByRow(row);
+        let colPath, rowPath;
+        if (col >= 0 && (colPath = this.columnDimensionTree.getTreePath(recordCol, this.showHeader && this.showColumnHeader ? row - (this.columnHeaderTitle ? 1 : 0) : this.columnDimensionTree.totalLevel)), 
+        row >= 0) if ("tree" === this.rowHierarchyType) if (col >= this.rowHeaderLevelCount) rowPath = this.rowDimensionTree.getTreePath(recordRow, col + this.rowDimensionTree.totalLevel); else {
+            const hd = this.getHeader(col, row);
+            rowPath = this.rowDimensionTree.getTreePath(recordRow, col + hd.hierarchyLevel);
+        } else rowPath = this.rowDimensionTree.getTreePath(recordRow, this.showHeader && this.showRowHeader ? col - (this.rowHeaderTitle ? 1 : 0) : this.rowDimensionTree.totalLevel);
+        const p = {
+            colHeaderPaths: colPath,
+            rowHeaderPaths: rowPath
+        };
+        return this._CellHeaderPathMap.set(`${col}-${row}`, p), p;
+    }
+    getCellHeaderPaths(col, row) {
+        const headerPathsWidthNode = this.getCellHeaderPathsWidthTreeNode(col, row), headerPaths = {
+            colHeaderPaths: [],
+            rowHeaderPaths: []
+        };
+        return headerPathsWidthNode.colHeaderPaths.forEach((colHeader => {
+            var _a, _b, _c;
+            const colHeaderPath = {};
+            colHeaderPath.dimensionKey = colHeader.dimensionKey, colHeaderPath.indicatorKey = colHeader.indicatorKey, 
+            colHeaderPath.value = null !== (_c = null !== (_a = colHeader.value) && void 0 !== _a ? _a : null === (_b = this.getIndicatorInfoByIndicatorKey(colHeader.indicatorKey)) || void 0 === _b ? void 0 : _b.caption) && void 0 !== _c ? _c : "", 
+            headerPaths.colHeaderPaths.push(colHeaderPath);
+        })), headerPathsWidthNode.rowHeaderPaths.forEach((rowHeader => {
+            var _a, _b, _c;
+            const rowHeaderPath = {};
+            rowHeaderPath.dimensionKey = rowHeader.dimensionKey, rowHeaderPath.indicatorKey = rowHeader.indicatorKey, 
+            rowHeaderPath.value = null !== (_c = null !== (_a = rowHeader.value) && void 0 !== _a ? _a : null === (_b = this.getIndicatorInfoByIndicatorKey(rowHeader.indicatorKey)) || void 0 === _b ? void 0 : _b.caption) && void 0 !== _c ? _c : "", 
+            headerPaths.rowHeaderPaths.push(rowHeaderPath);
+        })), headerPaths;
+    }
+    getIndicatorInfoByIndicatorKey(indicatorKey) {
+        var _a;
+        return null === (_a = this.indicatorsDefine) || void 0 === _a ? void 0 : _a.find((indicator => "string" != typeof indicator && (!!indicatorKey && indicator.indicatorKey === indicatorKey)));
+    }
+    getHeaderDimension(col, row) {
+        var _a, _b, _c;
+        if (this.isHeader(col, row)) {
+            const header = this.getHeader(col, row);
+            return null !== (_b = null === (_a = this.rowsDefine) || void 0 === _a ? void 0 : _a.find((dimension => "string" != typeof dimension && dimension.dimensionKey === header.field))) && void 0 !== _b ? _b : null === (_c = this.columnsDefine) || void 0 === _c ? void 0 : _c.find((dimension => "string" != typeof dimension && dimension.dimensionKey === header.field));
+        }
+    }
+    isColumnIndicatorHeader(col, row) {
+        return "column" === this._indicatorShowType && row === this.columnHeaderLevelCount - 1 && col >= this.rowHeaderLevelCount;
+    }
+    isRowIndicatorHeader(col, row) {
+        return "row" === this._indicatorShowType && col === this.rowHeaderLevelCount - 1 && row >= this.columnHeaderLevelCount;
+    }
+    isIndicatorHeader(col, row) {
+        return this.isColumnIndicatorHeader(col, row) || this.isRowIndicatorHeader(col, row);
+    }
+    toggleHierarchyState(col, row) {
+        var _a;
+        const hd = this.getHeader(col, row);
+        if (hd.define.hierarchyState = hd.define.hierarchyState === HierarchyState.collapse ? HierarchyState.expand : HierarchyState.collapse, 
+        this.rowDimensionTree.reset(this.rowDimensionTree.tree.children, !0), this._rowHeaderCellIds = [], 
+        this.rowHeaderObjs = this._addHeadersForTreeMode(this._rowHeaderCellIds, 0, this.rowDimensionTree.tree.children, [], this.rowDimensionTree.totalLevel, !0), 
+        this.rowHeaderTitle) {
+            const id = ++seqId, firstColIds = Array(this.rowCount - this.columnHeaderLevelCount).fill(id);
+            this._rowHeaderCellIds.unshift(firstColIds);
+            const cell = {
+                id: id,
+                caption: "string" == typeof this.rowHeaderTitle.title ? this.rowHeaderTitle.title : this.rowsDefine.reduce(((title, value) => "string" == typeof value ? title : title + (title ? `/${value.dimensionTitle}` : `${value.dimensionTitle}`)), ""),
+                field: void 0,
+                headerType: null !== (_a = this.rowHeaderTitle.headerType) && void 0 !== _a ? _a : "text",
+                style: this.rowHeaderTitle.headerStyle,
+                define: {
+                    field: "",
+                    headerType: "text",
+                    columnType: "text"
+                }
+            };
+            this.rowHeaderObjs.push(cell), this._headerObjects[id] = cell;
+        }
+        colIndex = 0, this._rowHeaderCellIds = transpose(this._rowHeaderCellIds), this._headerObjectMap = this._headerObjects.reduce(((o, e) => (o[e.id] = e, 
+        o)), {}), this._CellHeaderPathMap = new Map;
+    }
+    isHeaderForColWidth(col, row) {
+        return this.isHeader(col, row);
+    }
+    getHeaderForColWidth(col, row) {
+        return this.getHeader(col, row);
+    }
+    getPivotCellAdress(dimensions) {
+        var _a;
+        if (!Array.isArray(dimensions)) return;
+        let rowDimension, colDimension, rowArr = this.rowTree, colArr = this.columnTree;
+        for (let i = 0; i < dimensions.length; i++) {
+            const highlightDimension = dimensions[i];
+            if ((highlightDimension.isPivotCorner || !highlightDimension.value) && i === dimensions.length - 1) {
+                if ("row" === (null === (_a = null == this ? void 0 : this.cornerSetting) || void 0 === _a ? void 0 : _a.titleOnDimension)) {
+                    let col = 0;
+                    return "grid" === this.rowHierarchyType && (col = this.rowDimensionKeys.indexOf(highlightDimension.dimensionKey)), 
+                    -1 === col ? void 0 : {
+                        col: this.rowHeaderTitle ? col + 1 : col,
+                        row: 0
+                    };
+                }
+                const row = this.colDimensionKeys.indexOf(highlightDimension.dimensionKey);
+                return -1 === row ? void 0 : {
+                    col: 0,
+                    row: this.columnHeaderTitle ? row + 1 : row
+                };
+            }
+            let isCol = !1;
+            for (let j = 0; j < colArr.length; j++) {
+                const dimension = colArr[j];
+                if ((isValid(highlightDimension.dimensionKey) && dimension.dimensionKey === highlightDimension.dimensionKey || isValid(highlightDimension.indicatorKey) && dimension.indicatorKey === highlightDimension.indicatorKey) && dimension.value === highlightDimension.value) {
+                    colArr = dimension.children, colDimension = dimension, isCol = !0;
+                    break;
+                }
+            }
+            if (!isCol) for (let k = 0; k < rowArr.length; k++) {
+                const dimension = rowArr[k];
+                if ((isValid(highlightDimension.dimensionKey) && dimension.dimensionKey === highlightDimension.dimensionKey || isValid(highlightDimension.indicatorKey) && dimension.indicatorKey === highlightDimension.indicatorKey) && dimension.value === highlightDimension.value) {
+                    rowArr = dimension.children, rowDimension = dimension;
+                    break;
+                }
+            }
+        }
+        let col = 0, row = 0;
+        if (rowDimension) {
+            row = this.columnHeaderLevelCount;
+            const {startInTotal: startInTotal, level: level} = rowDimension;
+            return row += startInTotal, col = "grid" === this.rowHierarchyType ? this.rowHeaderTitle ? level + 1 : level : 0, 
+            {
+                col: col,
+                row: row
+            };
+        }
+        if (colDimension) {
+            col = this.rowHeaderLevelCount;
+            const {startInTotal: startInTotal, level: level} = colDimension;
+            return col += startInTotal, row = this.columnHeaderTitle ? level + 1 : level, {
+                col: col,
+                row: row
+            };
+        }
+    }
+    getPivotDimensionInfo(col, row) {
+        var _a;
+        const {colHeaderPaths: colHeaderPaths, rowHeaderPaths: rowHeaderPaths} = this.getCellHeaderPaths(col, row), pivotInfo = [];
+        return colHeaderPaths.length ? colHeaderPaths.forEach(((path, i) => {
+            pivotInfo.push({
+                dimensionKey: path.dimensionKey,
+                value: path.value,
+                isPivotCorner: !1,
+                indicatorKey: path.indicatorKey
+            });
+        })) : rowHeaderPaths.length ? rowHeaderPaths.forEach(((path, i) => {
+            pivotInfo.push({
+                dimensionKey: path.dimensionKey,
+                value: path.value,
+                isPivotCorner: !1,
+                indicatorKey: path.indicatorKey
+            });
+        })) : this.isCornerHeader(col, row) && ("row" === (null === (_a = null == this ? void 0 : this.cornerSetting) || void 0 === _a ? void 0 : _a.titleOnDimension) ? pivotInfo.push({
+            dimensionKey: this.rowDimensionKeys[this.rowHeaderTitle ? col - 1 : col],
+            isPivotCorner: !0
+        }) : pivotInfo.push({
+            dimensionKey: this.colDimensionKeys[this.columnHeaderTitle ? row - 1 : row],
+            isPivotCorner: !0
+        })), pivotInfo;
+    }
+    getIndicatorKey(col, row) {
+        var _a;
+        return null === (_a = this.getBody(col, row)) || void 0 === _a ? void 0 : _a.indicatorKey;
+    }
+    getParentCellId(col, row) {
+        if (0 !== row) return this.isColumnHeader(col, row) ? this.getCellId(col, row - 1) : this.isRowHeader(col, row) ? this.getCellId(col - 1, row) : void 0;
+    }
+    canMoveHeaderPosition(source, target) {
+        const sourceCellRange = this.getCellRange(source.col, source.row);
+        if (this.isColumnHeader(source.col, source.row)) {
+            return this.getParentCellId(source.col, sourceCellRange.start.row) === this.getParentCellId(target.col, sourceCellRange.start.row);
+        }
+        if (this.isRowHeader(source.col, source.row)) {
+            if ("tree" !== this.rowHierarchyType) {
+                return this.getParentCellId(sourceCellRange.start.col, source.row) === this.getParentCellId(sourceCellRange.start.col, target.row);
+            }
+            {
+                const sourceRowHeaderPaths = cloneDeep(this.getCellHeaderPathsWidthTreeNode(source.col, source.row).rowHeaderPaths), targetRowHeaderPaths = cloneDeep(this.getCellHeaderPathsWidthTreeNode(target.col, target.row).rowHeaderPaths);
+                if (sourceRowHeaderPaths.pop(), targetRowHeaderPaths.pop(), sourceRowHeaderPaths.length <= targetRowHeaderPaths.length) return sourceRowHeaderPaths.length !== targetRowHeaderPaths.length || !sourceRowHeaderPaths.find(((item, i) => item.dimensionKey !== targetRowHeaderPaths[i].dimensionKey || item.value !== targetRowHeaderPaths[i].value));
+            }
+        }
+        return !1;
+    }
+    moveHeaderPosition(source, target) {
+        if (this.canMoveHeaderPosition(source, target) && !this.isCellRangeEqual(source.col, source.row, target.col, target.row)) {
+            const sourceCellRange = this.getCellRange(source.col, source.row);
+            if (this.isColumnHeader(source.col, source.row)) {
+                const moveSize = sourceCellRange.end.col - sourceCellRange.start.col + 1;
+                let targetIndex;
+                const targetCellRange = this.getCellRange(target.col, sourceCellRange.start.row);
+                if (targetIndex = target.col >= source.col ? targetCellRange.end.col - moveSize + 1 : targetCellRange.start.col, 
+                targetIndex === sourceCellRange.end.col) return null;
+                for (let row = 0; row < this._columnHeaderCellIds.length; row++) {
+                    const sourceIds = this._columnHeaderCellIds[row].splice(sourceCellRange.start.col - this.rowHeaderLevelCount, moveSize);
+                    sourceIds.unshift(targetIndex - this.rowHeaderLevelCount, 0), Array.prototype.splice.apply(this._columnHeaderCellIds[row], sourceIds);
+                }
+                const sourceColumns = this._columnWidths.splice(sourceCellRange.start.col, moveSize);
+                return sourceColumns.unshift(targetIndex, 0), Array.prototype.splice.apply(this._columnWidths, sourceColumns), 
+                this.columnDimensionTree.movePosition(source.row, sourceCellRange.start.col - this.rowHeaderLevelCount, targetIndex - this.rowHeaderLevelCount), 
+                this.columnDimensionTree.reset(this.columnDimensionTree.tree.children, !0), this._CellHeaderPathMap = new Map, 
+                this._cellRangeMap = new Map, {
+                    sourceIndex: sourceCellRange.start.col,
+                    targetIndex: targetIndex,
+                    moveSize: moveSize,
+                    moveType: "column"
+                };
+            }
+            if (this.isRowHeader(source.col, source.row)) {
+                let targetIndex;
+                const sourceRowHeaderPaths = this.getCellHeaderPathsWidthTreeNode(source.col, source.row).rowHeaderPaths, targetRowHeaderPaths = this.getCellHeaderPathsWidthTreeNode(target.col, target.row).rowHeaderPaths, sourceRowHeaderNode = sourceRowHeaderPaths[sourceRowHeaderPaths.length - 1], targetRowHeaderNode = targetRowHeaderPaths[sourceRowHeaderPaths.length - 1], moveSize = sourceRowHeaderNode.size;
+                if (targetIndex = target.row >= source.row ? targetRowHeaderNode.startInTotal + targetRowHeaderNode.size - moveSize : targetRowHeaderNode.startInTotal, 
+                targetIndex === source.row || targetIndex === sourceCellRange.end.row) return null;
+                const sourceIds = this._rowHeaderCellIds.splice(sourceCellRange.start.row - this.columnHeaderLevelCount, moveSize);
+                return sourceIds.unshift(targetIndex, 0), Array.prototype.splice.apply(this._rowHeaderCellIds, sourceIds), 
+                this.rowDimensionTree.movePosition(this.getCellHeaderPathsWidthTreeNode(source.col, source.row).rowHeaderPaths.length - 1, sourceCellRange.start.row - this.columnHeaderLevelCount, targetIndex + (target.row > source.row ? sourceRowHeaderNode.size - 1 : 0)), 
+                this.rowDimensionTree.reset(this.rowDimensionTree.tree.children, !0), this._CellHeaderPathMap = new Map, 
+                this._cellRangeMap = new Map, {
+                    sourceIndex: sourceCellRange.start.row,
+                    targetIndex: targetIndex + this.columnHeaderLevelCount,
+                    moveSize: moveSize,
+                    moveType: "row"
+                };
+            }
+        }
+        return null;
+    }
+    getCellAdressByHeaderPath(dimensionPaths) {
+        let colHeaderPaths, rowHeaderPaths;
+        if (Array.isArray(dimensionPaths)) {
+            if (dimensionPaths.length > this.rowDimensionKeys.length + this.colDimensionKeys.length) return;
+            colHeaderPaths = dimensionPaths.filter((path => this.colDimensionKeys.indexOf(path.dimensionKey) >= 0)), 
+            rowHeaderPaths = dimensionPaths.filter((path => this.rowDimensionKeys.indexOf(path.dimensionKey) >= 0));
+        } else colHeaderPaths = dimensionPaths.colHeaderPaths, rowHeaderPaths = dimensionPaths.rowHeaderPaths;
+        if (!Array.isArray(colHeaderPaths) && !Array.isArray(rowHeaderPaths)) return;
+        null == colHeaderPaths || colHeaderPaths.sort(((a, b) => {
+            var _a, _b;
+            return this.colDimensionKeys.indexOf(null !== (_a = a.dimensionKey) && void 0 !== _a ? _a : this.indicatorDimensionKey) - this.colDimensionKeys.indexOf(null !== (_b = b.dimensionKey) && void 0 !== _b ? _b : this.indicatorDimensionKey);
+        })), null == rowHeaderPaths || rowHeaderPaths.sort(((a, b) => {
+            var _a, _b;
+            return this.rowDimensionKeys.indexOf(null !== (_a = a.dimensionKey) && void 0 !== _a ? _a : this.indicatorDimensionKey) - this.rowDimensionKeys.indexOf(null !== (_b = b.dimensionKey) && void 0 !== _b ? _b : this.indicatorDimensionKey);
+        }));
+        let col, row, defaultCol, defaultRow, needLowestLevel = !1;
+        (null == colHeaderPaths ? void 0 : colHeaderPaths.length) >= 1 && (null == rowHeaderPaths ? void 0 : rowHeaderPaths.length) >= 1 && (needLowestLevel = !0);
+        let rowDimensionFinded, colDimensionFinded, rowArr = this.rowTree, colArr = this.columnTree;
+        if (colHeaderPaths) for (let i = 0; i < colHeaderPaths.length; i++) {
+            const colDimension = colHeaderPaths[i];
+            for (let j = 0; j < colArr.length; j++) {
+                const dimension = colArr[j];
+                if ((isValid(colDimension.dimensionKey) && dimension.dimensionKey === colDimension.dimensionKey || isValid(colDimension.indicatorKey) && dimension.indicatorKey === colDimension.indicatorKey) && dimension.value === colDimension.value) {
+                    colArr = dimension.children, needLowestLevel && !colArr ? colDimensionFinded = dimension : needLowestLevel || (colDimensionFinded = dimension);
+                    break;
+                }
+            }
+        }
+        if (rowHeaderPaths) for (let i = 0; i < rowHeaderPaths.length; i++) {
+            const rowDimension = rowHeaderPaths[i];
+            for (let j = 0; j < rowArr.length; j++) {
+                const dimension = rowArr[j];
+                if ((isValid(rowDimension.dimensionKey) && dimension.dimensionKey === rowDimension.dimensionKey || isValid(rowDimension.indicatorKey) && dimension.indicatorKey === rowDimension.indicatorKey) && dimension.value === rowDimension.value) {
+                    rowArr = dimension.children, needLowestLevel && !rowArr ? rowDimensionFinded = dimension : needLowestLevel || (rowDimensionFinded = dimension);
+                    break;
+                }
+            }
+        }
+        if (!needLowestLevel || rowDimensionFinded && colDimensionFinded) {
+            if (rowDimensionFinded) {
+                row = this.columnHeaderLevelCount;
+                const {startInTotal: startInTotal, level: level} = rowDimensionFinded;
+                row += startInTotal, defaultCol = "grid" === this.rowHierarchyType ? this.rowHeaderTitle ? level + 1 : level : 0;
+            }
+            if (colDimensionFinded) {
+                col = this.rowHeaderLevelCount;
+                const {startInTotal: startInTotal, level: level} = colDimensionFinded;
+                col += startInTotal, defaultRow = this.columnHeaderTitle ? level + 1 : level;
+            }
+            return isValid(col) || isValid(row) ? {
+                col: null != col ? col : defaultCol,
+                row: null != row ? row : defaultRow
+            } : void 0;
+        }
+    }
+}
+//# sourceMappingURL=pivot-header-layout.js.map