@visactor/vtable 1.5.5-beta.0 → 1.5.6

package/dist/vtable.js

@@ -54819,7 +54819,7 @@
                     ctx.rect(clipBound.x1, clipBound.y1, clipBound.x2 - clipBound.x1, clipBound.y2 - clipBound.y1);
                     ctx.clip();
                     ctx.clearMatrix();
-                    if (!chartStage.needRender) {
+                    if (table.options.canvas && !chartStage.needRender) {
                         chartStage.pauseRender();
                         table.scenegraph.stage.dirtyBounds.union(this.globalAABBBounds);
                         table.scenegraph.updateNextFrame();
@@ -60059,66 +60059,144 @@
     }
 
     function updateChartSizeForResizeColWidth(scenegraph, col) {
-        for (let c = col; c <= scenegraph.proxy.colEnd; c++) {
-            const columnGroup = scenegraph.getColGroup(c);
-            columnGroup?.getChildren()?.forEach((cellNode) => {
-                const width = scenegraph.table.getColWidth(cellNode.col);
-                const height = scenegraph.table.getRowHeight(cellNode.row);
-                cellNode.children.forEach((node) => {
-                    if (node.type === 'chart') {
-                        node.cacheCanvas = null;
-                        node.setAttribute('width', Math.ceil(width - node.attribute.cellPadding[3] - node.attribute.cellPadding[1]));
-                        node.setAttribute('height', Math.ceil(height - node.attribute.cellPadding[0] - node.attribute.cellPadding[2]));
-                    }
-                });
+        const { table } = scenegraph;
+        const layout = table.internalProps.layoutMap;
+        const columnResizeType = col === -1 ? 'all' : table.internalProps.columnResizeType;
+        if (columnResizeType === 'column') {
+            const columnGroup = scenegraph.getColGroup(col);
+            columnGroup?.forEachChildren((cellNode) => {
+                const width = table.getColWidth(cellNode.col);
+                const height = table.getRowHeight(cellNode.row);
+                updateChartGraphicSize(cellNode, width, height);
             });
+            if (table.widthMode === 'adaptive' && col < table.colCount - 1) {
+                const columnGroup = scenegraph.getColGroup(col + 1);
+                columnGroup?.forEachChildren((cellNode) => {
+                    const width = table.getColWidth(cellNode.col);
+                    const height = table.getRowHeight(cellNode.row);
+                    updateChartGraphicSize(cellNode, width, height);
+                });
+            }
         }
-        if (!scenegraph.table.isPivotChart() && scenegraph.table.rightFrozenColCount >= 1) {
-            for (let c = scenegraph.table.colCount - scenegraph.table.rightFrozenColCount; c <= scenegraph.table.colCount - 1; c++) {
+        else {
+            let startCol = table.rowHeaderLevelCount;
+            let endCol = table.colCount - 1;
+            let resizeIndicatorKey;
+            let resizeDimensionKey;
+            let resizeDimensionValue;
+            if (columnResizeType === 'indicator') {
+                if (layout.indicatorsAsCol) {
+                    resizeIndicatorKey = layout.getIndicatorKey(col, table.columnHeaderLevelCount);
+                }
+                else {
+                    const headerPaths = layout.getCellHeaderPaths(col, table.columnHeaderLevelCount - 1);
+                    const headerPath = headerPaths.colHeaderPaths[headerPaths.colHeaderPaths.length - 1];
+                    resizeDimensionKey = headerPath.dimensionKey;
+                    resizeDimensionValue = headerPath.value;
+                }
+            }
+            else if (columnResizeType === 'indicatorGroup') {
+                const layout = table.internalProps.layoutMap;
+                const headerPaths = layout.getCellHeaderPaths(table.stateManager.columnResize.col, table.columnHeaderLevelCount);
+                const node = layout.getHeadNodeByRowOrColDimensions(headerPaths.colHeaderPaths.slice(0, headerPaths.colHeaderPaths.length - 1));
+                startCol = node.startInTotal + table.frozenColCount;
+                endCol = node.startInTotal + table.frozenColCount + node.size - 1;
+            }
+            for (let c = startCol; c <= endCol; c++) {
                 const columnGroup = scenegraph.getColGroup(c);
-                columnGroup?.getChildren()?.forEach((cellNode) => {
-                    const width = scenegraph.table.getColWidth(cellNode.col);
-                    const height = scenegraph.table.getRowHeight(cellNode.row);
-                    cellNode.children.forEach((node) => {
-                        if (node.type === 'chart') {
-                            node.cacheCanvas = null;
-                            node.setAttribute('width', Math.ceil(width - node.attribute.cellPadding[3] - node.attribute.cellPadding[1]));
-                            node.setAttribute('height', Math.ceil(height - node.attribute.cellPadding[0] - node.attribute.cellPadding[2]));
+                if (columnGroup) {
+                    if (columnResizeType === 'indicator') {
+                        const indicatorKey = layout.getIndicatorKey(c, table.columnHeaderLevelCount);
+                        if (layout.indicatorsAsCol && indicatorKey !== resizeIndicatorKey) {
+                            continue;
                         }
+                        else if (!layout.indicatorsAsCol) {
+                            const headerPaths = layout.getCellHeaderPaths(c, table.columnHeaderLevelCount - 1);
+                            const headerPath = headerPaths?.colHeaderPaths[headerPaths.colHeaderPaths.length - 1];
+                            if (!headerPath ||
+                                resizeDimensionKey !== headerPath.dimensionKey ||
+                                resizeDimensionValue !== headerPath.value) {
+                                continue;
+                            }
+                        }
+                    }
+                    columnGroup.forEachChildren((cellNode) => {
+                        const width = table.getColWidth(cellNode.col);
+                        const height = table.getRowHeight(cellNode.row);
+                        updateChartGraphicSize(cellNode, width, height);
                     });
-                });
+                }
             }
         }
     }
     function updateChartSizeForResizeRowHeight(scenegraph, row) {
-        const updateCellNode = (c, r) => {
-            const cellNode = scenegraph.getCell(c, r);
-            const width = scenegraph.table.getColWidth(cellNode.col);
-            const height = scenegraph.table.getRowHeight(cellNode.row);
-            cellNode.children.forEach((node) => {
-                if (node.type === 'chart') {
-                    node.cacheCanvas = null;
-                    node.setAttribute('width', Math.ceil(width - node.attribute.cellPadding[3] - node.attribute.cellPadding[1]));
-                    node.setAttribute('height', Math.ceil(height - node.attribute.cellPadding[0] - node.attribute.cellPadding[2]));
-                }
-            });
-        };
-        for (let c = scenegraph.proxy.colStart; c <= scenegraph.proxy.colEnd; c++) {
-            for (let r = row; r <= scenegraph.proxy.rowEnd; r++) {
-                updateCellNode(c, r);
+        const { table } = scenegraph;
+        const layout = table.internalProps.layoutMap;
+        const state = table.stateManager;
+        const rowResizeType = row === -1 ? 'all' : table.internalProps.rowResizeType;
+        let startRow = table.columnHeaderLevelCount;
+        let endRow = table.rowCount - 1;
+        let resizeIndicatorKey;
+        let resizeDimensionKey;
+        let resizeDimensionValue;
+        if (rowResizeType === 'indicator') {
+            if (!layout.indicatorsAsCol) {
+                resizeIndicatorKey = layout.getIndicatorKey(table.rowHeaderLevelCount, row);
             }
-        }
-        if (scenegraph.table.rightFrozenColCount >= 1) {
-            for (let c = scenegraph.table.colCount - scenegraph.table.rightFrozenColCount; c <= scenegraph.table.colCount - 1; c++) {
-                for (let r = row; r <= scenegraph.proxy.rowEnd; r++) {
-                    updateCellNode(c, r);
+            else {
+                const headerPaths = layout.getCellHeaderPaths(table.rowHeaderLevelCount - 1, row);
+                const headerPath = headerPaths.rowHeaderPaths?.[headerPaths.rowHeaderPaths.length - 1];
+                resizeDimensionKey = headerPath?.dimensionKey;
+                resizeDimensionValue = headerPath?.value;
+            }
+        }
+        else if (rowResizeType === 'indicatorGroup') {
+            const layout = table.internalProps.layoutMap;
+            const headerPaths = layout.getCellHeaderPaths(table.rowHeaderLevelCount, row);
+            const node = layout.getHeadNodeByRowOrColDimensions(headerPaths.rowHeaderPaths.slice(0, headerPaths.rowHeaderPaths.length - 1));
+            startRow = node.startInTotal + table.frozenRowCount;
+            endRow = node.startInTotal + table.frozenRowCount + node.size - 1;
+        }
+        for (let col = scenegraph.proxy.colStart; col <= scenegraph.proxy.colEnd; col++) {
+            if (rowResizeType === 'row') {
+                const cellNode = scenegraph.highPerformanceGetCell(col, row);
+                if (cellNode.role !== 'cell') {
+                    continue;
+                }
+                const width = table.getColWidth(cellNode.col);
+                const height = table.getRowHeight(cellNode.row);
+                updateChartGraphicSize(cellNode, width, height);
+                if (table.heightMode === 'adaptive' && row < table.rowCount - 1) {
+                    const cellNode = scenegraph.highPerformanceGetCell(col, row + 1);
+                    const width = table.getColWidth(cellNode.col);
+                    const height = table.getRowHeight(cellNode.row);
+                    updateChartGraphicSize(cellNode, width, height);
                 }
             }
-        }
-        if (scenegraph.table.frozenColCount >= 1) {
-            for (let c = 0; c <= scenegraph.table.frozenColCount - 1; c++) {
-                for (let r = row; r <= scenegraph.proxy.rowEnd; r++) {
-                    updateCellNode(c, r);
+            else {
+                for (let r = startRow; r <= endRow; r++) {
+                    if (rowResizeType === 'indicator') {
+                        const indicatorKey = layout.getIndicatorKey(state.table.rowHeaderLevelCount, r);
+                        if (!layout.indicatorsAsCol && indicatorKey !== resizeIndicatorKey) {
+                            continue;
+                        }
+                        else if (layout.indicatorsAsCol) {
+                            const headerPaths = layout.getCellHeaderPaths(state.table.rowHeaderLevelCount - 1, r);
+                            const headerPath = headerPaths?.rowHeaderPaths[headerPaths.rowHeaderPaths.length - 1];
+                            if (!headerPath ||
+                                resizeDimensionKey !== headerPath.dimensionKey ||
+                                resizeDimensionValue !== headerPath.value) {
+                                continue;
+                            }
+                        }
+                    }
+                    const cellNode = scenegraph.highPerformanceGetCell(col, r);
+                    if (cellNode.role !== 'cell') {
+                        continue;
+                    }
+                    const width = table.getColWidth(cellNode.col);
+                    const height = table.getRowHeight(cellNode.row);
+                    updateChartGraphicSize(cellNode, width, height);
                 }
             }
         }
@@ -60235,6 +60313,17 @@
             }
         });
     }
+    function updateChartGraphicSize(cellNode, width, height) {
+        cellNode.forEachChildren((graphic) => {
+            if (graphic.type === 'chart') {
+                graphic.cacheCanvas = null;
+                graphic.setAttributes({
+                    width: Math.ceil(width - graphic.attribute.cellPadding[3] - graphic.attribute.cellPadding[1]),
+                    height: Math.ceil(height - graphic.attribute.cellPadding[0] - graphic.attribute.cellPadding[2])
+                });
+            }
+        });
+    }
 
     function initSceneGraph(scene) {
         const width = scene.table.tableNoFrameWidth;
@@ -61413,8 +61502,8 @@
         updateChartSizeForResizeColWidth(col) {
             updateChartSizeForResizeColWidth(this, col);
         }
-        updateChartSizeForResizeRowHeight(col) {
-            updateChartSizeForResizeRowHeight(this, col);
+        updateChartSizeForResizeRowHeight(row) {
+            updateChartSizeForResizeRowHeight(this, row);
         }
         updateChartState(datum) {
             this.table.isPivotChart() && updateChartState(this, datum);
@@ -61550,7 +61639,7 @@
                 this.table.heightMode === 'adaptive' ||
                 this.table.autoFillWidth ||
                 this.table.autoFillHeight) {
-                this.updateChartSizeForResizeColWidth(this.table.rowHeaderLevelCount);
+                this.updateChartSizeForResizeColWidth(-1);
             }
             this.proxy.progress();
             this.updateNextFrame();
@@ -63818,7 +63907,7 @@
         state.table.scenegraph.updateNextFrame();
     }
     function updateResizeColForRow(detaY, state) {
-        if (state.table.heightMode === 'adaptive' && state.rowResize.row < state.table.colCount - 1) {
+        if (state.table.heightMode === 'adaptive' && state.rowResize.row < state.table.rowCount - 1) {
             state.table.scenegraph.updateRowHeight(state.rowResize.row, detaY);
             state.table.scenegraph.updateRowHeight(state.rowResize.row + 1, -detaY);
             state.table.internalProps._heightResizedRowMap.add(state.rowResize.row);
@@ -64305,7 +64394,7 @@
             setTimeout(() => {
                 this.rowResize.resizing = false;
             }, 0);
-            this.table.scenegraph.updateChartSizeForResizeColWidth(this.rowResize.row);
+            this.table.scenegraph.updateChartSizeForResizeRowHeight(this.rowResize.row);
             this.table.scenegraph.component.hideResizeRow();
             this.table.scenegraph.updateNextFrame();
         }
@@ -70723,7 +70812,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.5.5-beta.0";
+        version = "1.5.6";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -76532,7 +76621,7 @@
                     notFillHeight = this.getAllRowsHeight() <= this.tableNoFrameHeight;
                 }
                 if (this.widthMode === 'adaptive' || notFillWidth || this.heightMode === 'adaptive' || notFillHeight) {
-                    this.scenegraph.updateChartSizeForResizeColWidth(0);
+                    this.scenegraph.updateChartSizeForResizeColWidth(-1);
                 }
             }
         }
@@ -87184,7 +87273,7 @@
                     notFillHeight = this.getAllRowsHeight() <= this.tableNoFrameHeight;
                 }
                 if (this.widthMode === 'adaptive' || notFillWidth || this.heightMode === 'adaptive' || notFillHeight) {
-                    this.scenegraph.updateChartSizeForResizeColWidth(0);
+                    this.scenegraph.updateChartSizeForResizeColWidth(-1);
                 }
             }
         }
@@ -89284,7 +89373,7 @@
     }
 
     registerForVrender();
-    const version = "1.5.5-beta.0";
+    const version = "1.5.6";
     function getIcons() {
         return get$2();
     }