@visactor/vtable 0.20.4-alpha.2 → 0.21.0

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

@@ -805,7 +805,7 @@ export class PivotHeaderLayoutMap {
         this.colIndex = 0, this._headerObjectMap = this._headerObjects.reduce(((o, e) => (o[e.id] = e, 
         o)), {}), this._CellHeaderPathMap = new Map, this._largeCellRangeCache.length = 0;
         const diffCell = diffCellAddress(col, row, oldRowHeaderCellIds.map((oldCellId => oldCellId[col])), this._rowHeaderCellIds_FULL.map((newCellId => newCellId[col])), oldRowHeaderCellPositons, this);
-        return this._rowHeaderCellIds = this._rowHeaderCellIds_FULL, diffCell;
+        return this._rowHeaderCellIds = this._rowHeaderCellIds_FULL.slice(), diffCell;
     }
     isHeaderForColWidth(col, row) {
         return this.isHeader(col, row);
@@ -921,7 +921,11 @@ export class PivotHeaderLayoutMap {
             }
             {
                 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));
+                if (sourceRowHeaderPaths.pop(), targetRowHeaderPaths.pop(), sourceRowHeaderPaths.length <= targetRowHeaderPaths.length) {
+                    if (sourceRowHeaderPaths.length === targetRowHeaderPaths.length) return !sourceRowHeaderPaths.find(((item, i) => item.dimensionKey !== targetRowHeaderPaths[i].dimensionKey || item.value !== targetRowHeaderPaths[i].value));
+                    if (sourceRowHeaderPaths.length > 0) for (let i = 0; i < sourceRowHeaderPaths.length; i++) if (sourceRowHeaderPaths[i].startInTotal !== targetRowHeaderPaths[i].startInTotal) return !1;
+                    return !0;
+                }
             }
         }
         return !1;
@@ -930,41 +934,43 @@ export class PivotHeaderLayoutMap {
         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;
+                const sourceSize = 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 - this.rowHeaderLevelCount) return null;
+                if (targetIndex = target.col >= source.col ? targetCellRange.end.col - sourceSize + 1 : targetCellRange.start.col, 
+                targetIndex === sourceCellRange.start.col) return null;
                 for (let row = 0; row < this._columnHeaderCellIds.length; row++) {
-                    const sourceIds = this._columnHeaderCellIds[row].splice(sourceCellRange.start.col - this.rowHeaderLevelCount, moveSize);
+                    const sourceIds = this._columnHeaderCellIds[row].splice(sourceCellRange.start.col - this.rowHeaderLevelCount, sourceSize);
                     sourceIds.unshift(targetIndex - this.rowHeaderLevelCount, 0), Array.prototype.splice.apply(this._columnHeaderCellIds[row], sourceIds);
                 }
-                const sourceColumns = this._columnWidths.splice(sourceCellRange.start.col, moveSize);
+                const sourceColumns = this._columnWidths.splice(sourceCellRange.start.col, sourceSize);
                 return sourceColumns.unshift(targetIndex, 0), Array.prototype.splice.apply(this._columnWidths, sourceColumns), 
-                this.columnDimensionTree.movePosition(this.getCellHeaderPathsWidthTreeNode(source.col, source.row).colHeaderPaths.length - 1, sourceCellRange.start.col - this.rowHeaderLevelCount, targetIndex - this.rowHeaderLevelCount), 
+                this.columnDimensionTree.movePosition(this.getCellHeaderPathsWidthTreeNode(source.col, source.row).colHeaderPaths.length - 1, sourceCellRange.start.col - this.rowHeaderLevelCount, targetCellRange.start.col - this.rowHeaderLevelCount), 
                 this.columnDimensionTree.reset(this.columnDimensionTree.tree.children, !0), this._CellHeaderPathMap = new Map, 
                 this._largeCellRangeCache.length = 0, {
                     sourceIndex: sourceCellRange.start.col,
                     targetIndex: targetIndex,
-                    moveSize: moveSize,
+                    sourceSize: sourceSize,
+                    targetSize: targetCellRange.end.col - targetCellRange.start.col + 1,
                     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 - this.columnHeaderLevelCount || targetIndex === sourceCellRange.end.row - this.columnHeaderLevelCount) return null;
-                const sourceIds = this._rowHeaderCellIds.splice(sourceCellRange.start.row - this.columnHeaderLevelCount, moveSize);
+                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], sourceSize = sourceRowHeaderNode.size;
+                if (targetIndex = target.row >= source.row ? targetRowHeaderNode.startInTotal + targetRowHeaderNode.size - sourceSize : targetRowHeaderNode.startInTotal, 
+                targetIndex === sourceCellRange.start.row - this.columnHeaderLevelCount) return null;
+                const sourceIds = this._rowHeaderCellIds.splice(sourceCellRange.start.row - this.columnHeaderLevelCount, sourceSize);
                 sourceIds.unshift(targetIndex - this.currentPageStartIndex, 0), Array.prototype.splice.apply(this._rowHeaderCellIds, sourceIds);
-                const sourceIds_FULL = this._rowHeaderCellIds_FULL.splice(sourceCellRange.start.row + this.currentPageStartIndex, moveSize);
+                const sourceIds_FULL = this._rowHeaderCellIds_FULL.splice(sourceCellRange.start.row - this.columnHeaderLevelCount + this.currentPageStartIndex, sourceSize);
                 return sourceIds_FULL.unshift(targetIndex, 0), Array.prototype.splice.apply(this._rowHeaderCellIds_FULL, sourceIds_FULL), 
-                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.movePosition(sourceRowHeaderPaths.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._largeCellRangeCache.length = 0, {
                     sourceIndex: sourceCellRange.start.row,
                     targetIndex: targetIndex + this.columnHeaderLevelCount,
-                    moveSize: moveSize,
+                    sourceSize: sourceSize,
+                    targetSize: targetRowHeaderNode.size,
                     moveType: "row"
                 };
             }
@@ -976,8 +982,8 @@ export class PivotHeaderLayoutMap {
         let colHeaderPaths, rowHeaderPaths, forceBody = !1;
         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));
+            colHeaderPaths = dimensionPaths.filter((path => this.colDimensionKeys.indexOf(path.dimensionKey) >= 0 || this.colDimensionKeys.indexOf(this.indicatorDimensionKey) >= 0 && path.indicatorKey)), 
+            rowHeaderPaths = dimensionPaths.filter((path => this.rowDimensionKeys.indexOf(path.dimensionKey) >= 0 || this.rowDimensionKeys.indexOf(this.indicatorDimensionKey) >= 0 && path.indicatorKey));
         } else colHeaderPaths = dimensionPaths.colHeaderPaths, rowHeaderPaths = dimensionPaths.rowHeaderPaths, 
         "body" === (null == dimensionPaths ? void 0 : dimensionPaths.cellLocation) && this._table.isPivotTable() && (forceBody = !0);
         if (!Array.isArray(colHeaderPaths) && !Array.isArray(rowHeaderPaths)) return;