@visactor/vtable 1.5.5 → 1.5.6

package/dist/vtable.js

@@ -44372,9 +44372,11 @@
     }
     function getPromiseValue(value, callback) {
         if (isPromise(value)) {
-            value.then(result => {
+            value
+                .then(result => {
                 callback(result);
-            }).catch((err) => {
+            })
+                .catch((err) => {
             });
         }
         else {
@@ -49119,8 +49121,8 @@
     function getCellEventArgsSet(e) {
         const tableEvent = {
             abstractPos: {
-                x: e.x,
-                y: e.y
+                x: e.viewport.x,
+                y: e.viewport.y
             }
         };
         const targetCell = getTargetCell(e.target);
@@ -54759,7 +54761,7 @@
             this.numberType = CHART_NUMBER_TYPE;
             this.isShareChartSpec = isShareChartSpec;
             if (!params.chartInstance) {
-                const chartInstance = new params.ClassType(params.spec, {
+                const chartInstance = (this.chartInstance = new params.ClassType(params.spec, merge({}, this.attribute.tableChartOption, {
                     renderCanvas: params.canvas,
                     mode: this.attribute.mode === 'node' ? 'node' : 'desktop-browser',
                     modeParams: this.attribute.modeParams,
@@ -54769,8 +54771,9 @@
                     interactive: false,
                     animation: false,
                     autoFit: false
-                });
+                })));
                 chartInstance.renderSync();
+                chartInstance.getStage().enableDirtyBounds();
                 params.chartInstance = this.chartInstance = chartInstance;
             }
             else {
@@ -54788,34 +54791,53 @@
                 y1: y1 - table.scrollTop,
                 y2: y2 - table.scrollTop
             });
-            this.activeChartInstance = new this.attribute.ClassType(this.attribute.spec, {
+            this.activeChartInstance = new this.attribute.ClassType(this.attribute.spec, merge({}, this.attribute.tableChartOption, {
                 renderCanvas: this.attribute.canvas,
                 mode: 'desktop-browser',
                 canvasControled: false,
                 viewBox: {
-                    x1: x1 - table.scrollLeft,
-                    x2: x2 - table.scrollLeft,
-                    y1: y1 - table.scrollTop,
-                    y2: y2 - table.scrollTop
+                    x1: 0,
+                    x2: x2 - x1,
+                    y1: 0,
+                    y2: y2 - y1
                 },
                 dpr: table.internalProps.pixelRatio,
                 animation: false,
                 interactive: true,
                 autoFit: false,
-                beforeRender: (stage) => {
-                    const ctx = stage.window.getContext();
+                beforeRender: (chartStage) => {
+                    const stage = this.stage;
+                    const ctx = chartStage.window.getContext();
+                    const stageMatrix = stage.window.getViewBoxTransform();
+                    const viewBox = stage.window.getViewBox();
                     ctx.inuse = true;
                     ctx.clearMatrix();
+                    ctx.setTransform(stageMatrix.a, stageMatrix.b, stageMatrix.c, stageMatrix.d, stageMatrix.e, stageMatrix.f, true);
+                    ctx.translate(viewBox.x1, viewBox.y1);
                     ctx.setTransformForCurrent(true);
                     ctx.beginPath();
                     ctx.rect(clipBound.x1, clipBound.y1, clipBound.x2 - clipBound.x1, clipBound.y2 - clipBound.y1);
                     ctx.clip();
+                    ctx.clearMatrix();
+                    if (table.options.canvas && !chartStage.needRender) {
+                        chartStage.pauseRender();
+                        table.scenegraph.stage.dirtyBounds.union(this.globalAABBBounds);
+                        table.scenegraph.updateNextFrame();
+                    }
                 },
                 afterRender(stage) {
                     const ctx = stage.window.getContext();
                     ctx.inuse = false;
+                    stage.needRender = false;
+                    chartStage.resumeRender();
                 }
-            });
+            }));
+            const chartStage = this.activeChartInstance.getStage();
+            const matrix = this.globalTransMatrix.clone();
+            const stageMatrix = this.stage.window.getViewBoxTransform();
+            matrix.multiply(stageMatrix.a, stageMatrix.b, stageMatrix.c, stageMatrix.d, stageMatrix.e, stageMatrix.f);
+            chartStage.window.setViewBoxTransform &&
+                chartStage.window.setViewBoxTransform(matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f);
             this.activeChartInstance.renderSync();
             table.internalProps.layoutMap?.updateDataStateToActiveChartInstance?.(this.activeChartInstance);
             this.activeChartInstance.on('click', (params) => {
@@ -54851,11 +54873,12 @@
             const cellGroup = this.parent;
             const padding = this.attribute.cellPadding;
             const table = this.stage.table;
+            const { x1, y1, x2, y2 } = cellGroup.globalAABBBounds;
             return {
-                x1: Math.ceil(cellGroup.globalAABBBounds.x1 + padding[3] + table.scrollLeft),
-                x2: Math.ceil(cellGroup.globalAABBBounds.x1 + cellGroup.attribute.width - padding[1] + table.scrollLeft),
-                y1: Math.ceil(cellGroup.globalAABBBounds.y1 + padding[0] + table.scrollTop),
-                y2: Math.ceil(cellGroup.globalAABBBounds.y1 + cellGroup.attribute.height - padding[2] + table.scrollTop)
+                x1: Math.ceil(x1 + padding[3] + table.scrollLeft + (table.options.viewBox?.x1 ?? 0)),
+                x2: Math.ceil(x1 + cellGroup.attribute.width - padding[1] + table.scrollLeft + (table.options.viewBox?.x1 ?? 0)),
+                y1: Math.ceil(y1 + padding[0] + table.scrollTop + (table.options.viewBox?.y1 ?? 0)),
+                y2: Math.ceil(y1 + cellGroup.attribute.height - padding[2] + table.scrollTop + (table.options.viewBox?.y1 ?? 0))
             };
         }
     }
@@ -54886,6 +54909,10 @@
             bodyBound.x1 = tableBound.x1 + table.getFrozenColsWidth();
             bodyBound.x2 = tableBound.x2 - table.getRightFrozenColsWidth();
         }
+        bodyBound.x1 = bodyBound.x1 + (table.options.viewBox?.x1 ?? 0);
+        bodyBound.x2 = bodyBound.x2 + (table.options.viewBox?.x1 ?? 0);
+        bodyBound.y1 = bodyBound.y1 + (table.options.viewBox?.y1 ?? 0);
+        bodyBound.y2 = bodyBound.y2 + (table.options.viewBox?.y1 ?? 0);
         return bodyBound;
     }
 
@@ -54926,46 +54953,65 @@
         if (viewBox.y2 <= viewBox.y1) {
             viewBox.y2 = viewBox.y1 + 1;
         }
-        axes?.forEach((axis, index) => {
-            if (axis.type === 'band') {
-                chartInstance.updateModelSpec({ type: 'axes', index }, { domain: axis.domain.slice(0) }, true);
-            }
-            else {
-                chartInstance.updateModelSpecSync({ type: 'axes', index }, { min: axis.range?.min ?? 0, max: axis.range?.max ?? 0 }, true);
-            }
-        });
         chartInstance.updateViewBox({
-            x1: viewBox.x1 - chart.getRootNode().table.scrollLeft,
-            x2: viewBox.x2 - chart.getRootNode().table.scrollLeft,
-            y1: viewBox.y1 - chart.getRootNode().table.scrollTop,
-            y2: viewBox.y2 - chart.getRootNode().table.scrollTop
+            x1: 0,
+            x2: viewBox.x2 - viewBox.x1,
+            y1: 0,
+            y2: viewBox.y2 - viewBox.y1
         }, false, false);
-        if (typeof dataId === 'string') {
-            chartInstance.updateDataSync(dataId, data ?? []);
-        }
-        else {
-            const dataBatch = [];
-            for (const dataIdStr in dataId) {
-                const dataIdAndField = dataId[dataIdStr];
-                const series = spec.series.find((item) => item?.data?.id === dataIdStr);
-                dataBatch.push({
-                    id: dataIdStr,
-                    values: dataIdAndField
-                        ? data?.filter((item) => {
-                            return item.hasOwnProperty(dataIdAndField);
-                        }) ?? []
-                        : data ?? [],
-                    fields: series?.data?.fields
-                });
-                if (!chartInstance.updateFullDataSync) {
-                    chartInstance.updateDataSync(dataIdStr, dataIdAndField
-                        ? data?.filter((item) => {
-                            return item.hasOwnProperty(dataIdAndField);
-                        }) ?? []
-                        : data ?? []);
+        const chartStage = chartInstance.getStage();
+        const matrix = chart.globalTransMatrix.clone();
+        const stageMatrix = chart.stage.window.getViewBoxTransform();
+        matrix.multiply(stageMatrix.a, stageMatrix.b, stageMatrix.c, stageMatrix.d, stageMatrix.e, stageMatrix.f);
+        chartStage.window.setViewBoxTransform &&
+            chartStage.window.setViewBoxTransform(matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f);
+        const { table } = chart.getRootNode();
+        let updateSpec = false;
+        if (table.options.specFormat) {
+            const formatResult = table.options.specFormat(chart.attribute.spec);
+            if (formatResult.needFormatSpec && formatResult.spec) {
+                const spec = formatResult.spec;
+                chartInstance.updateSpecSync(spec);
+                updateSpec = true;
+            }
+        }
+        if (!updateSpec) {
+            axes?.forEach((axis, index) => {
+                if (axis.type === 'band') {
+                    chartInstance.updateModelSpec({ type: 'axes', index }, { domain: axis.domain.slice(0) }, true);
+                }
+                else {
+                    chartInstance.updateModelSpecSync({ type: 'axes', index }, { min: axis.range?.min ?? 0, max: axis.range?.max ?? 0 }, true);
                 }
+            });
+            table.internalProps.layoutMap?.updateDataStateToActiveChartInstance?.(chartInstance);
+            if (typeof dataId === 'string') {
+                chartInstance.updateDataSync(dataId, data ?? []);
+            }
+            else {
+                const dataBatch = [];
+                for (const dataIdStr in dataId) {
+                    const dataIdAndField = dataId[dataIdStr];
+                    const series = spec.series.find((item) => item?.data?.id === dataIdStr);
+                    dataBatch.push({
+                        id: dataIdStr,
+                        values: dataIdAndField
+                            ? data?.filter((item) => {
+                                return item.hasOwnProperty(dataIdAndField);
+                            }) ?? []
+                            : data ?? [],
+                        fields: series?.data?.fields
+                    });
+                    if (!chartInstance.updateFullDataSync) {
+                        chartInstance.updateDataSync(dataIdStr, dataIdAndField
+                            ? data?.filter((item) => {
+                                return item.hasOwnProperty(dataIdAndField);
+                            }) ?? []
+                            : data ?? []);
+                    }
+                }
+                chartInstance.updateFullDataSync?.(dataBatch);
             }
-            chartInstance.updateFullDataSync?.(dataBatch);
         }
         const sg = chartInstance.getStage();
         cacheStageCanvas(sg, chart);
@@ -54992,7 +55038,7 @@
     function cacheStageCanvas(stage, chart) {
         const { viewWidth, viewHeight } = stage;
         if (viewWidth < cacheCanvasSizeLimit && viewHeight < cacheCanvasSizeLimit) {
-            chart.cacheCanvas = stage.toCanvas();
+            chart.cacheCanvas = toCanvas(stage);
             if (!chart.isShareChartSpec) {
                 chart.chartInstance?.release();
                 chart.chartInstance = null;
@@ -55013,7 +55059,7 @@
                 const height = endY - startY;
                 const bounds = new Bounds();
                 bounds.setValue(startX, startY, endX, endY);
-                const canvas = stage.toCanvas(false, bounds);
+                const canvas = toCanvas(stage, false, bounds);
                 cacheCanvas.push({
                     canvas,
                     x: startX,
@@ -55025,9 +55071,57 @@
         }
         chart.cacheCanvas = cacheCanvas;
     }
+    function toCanvas(stage, fullImage = true, viewBox) {
+        if (stage.releaseStatus === 'released') {
+            return null;
+        }
+        const matrix = stage.window.getViewBoxTransform();
+        const window = renderToNewWindow(stage, fullImage, viewBox);
+        window.setViewBoxTransform(matrix.a, matrix.b, matrix.c, matrix.d, 0, 0);
+        stage.renderTo(window);
+        const c = window.getNativeHandler();
+        if (c.nativeCanvas) {
+            return c.nativeCanvas;
+        }
+        return null;
+    }
+    function renderToNewWindow(stage, fullImage = true, viewBox) {
+        const matrix = stage.window.getViewBoxTransform();
+        const window = container.get(VWindow);
+        const x1 = viewBox ? -viewBox.x1 : 0;
+        const y1 = viewBox ? -viewBox.y1 : 0;
+        const x2 = viewBox ? viewBox.x2 : stage.viewWidth;
+        const y2 = viewBox ? viewBox.y2 : stage.viewHeight;
+        const width = viewBox ? viewBox.width() : stage.viewWidth;
+        const height = viewBox ? viewBox.height() : stage.viewHeight;
+        if (fullImage) {
+            window.create({
+                viewBox: { x1, y1, x2, y2 },
+                width: width * matrix.a,
+                height: height * matrix.d,
+                dpr: stage.window.dpr,
+                canvasControled: true,
+                offscreen: true,
+                title: ''
+            });
+        }
+        else {
+            window.create({
+                viewBox: { x1, y1, x2, y2 },
+                width: width * matrix.a,
+                height: height * matrix.d,
+                dpr: stage.window.dpr,
+                canvasControled: true,
+                offscreen: true,
+                title: ''
+            });
+        }
+        stage.renderTo(window);
+        return window;
+    }
 
     const ChartRender = Symbol.for('ChartRender');
-    let DefaultCanvasChartRender = class DefaultCanvasChartRender {
+    let DefaultCanvasChartRender = class DefaultCanvasChartRender extends BaseRender {
         type;
         numberType = CHART_NUMBER_TYPE;
         drawShape(chart, context, x, y, drawContext, params, fillCb, strokeCb) {
@@ -55035,6 +55129,7 @@
             const { dataId, data, spec } = chart.attribute;
             chart.getViewBox();
             const { width = groupAttribute.width, height = groupAttribute.height } = chart.attribute;
+            const { table } = chart.getRootNode();
             const { active, cacheCanvas, activeChartInstance } = chart;
             if (!active && cacheCanvas) {
                 if (isArray$1(cacheCanvas)) {
@@ -55048,6 +55143,27 @@
                 }
             }
             else if (activeChartInstance) {
+                if (table.options.specFormat) {
+                    const formatResult = table.options.specFormat(chart.attribute.spec);
+                    if (formatResult.needFormatSpec && formatResult.spec) {
+                        const spec = formatResult.spec;
+                        activeChartInstance.updateSpecSync(spec);
+                        return;
+                    }
+                }
+                const viewBox = chart.getViewBox();
+                activeChartInstance.updateViewBox({
+                    x1: 0,
+                    x2: viewBox.x2 - viewBox.x1,
+                    y1: 0,
+                    y2: viewBox.y2 - viewBox.y1
+                }, false, false);
+                const chartStage = activeChartInstance.getStage();
+                chartStage.needRender = true;
+                const matrix = chart.globalTransMatrix.clone();
+                const stageMatrix = chart.stage.window.getViewBoxTransform().clone();
+                stageMatrix.multiply(matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f);
+                chartStage.window.setViewBoxTransform(stageMatrix.a, stageMatrix.b, stageMatrix.c, stageMatrix.d, stageMatrix.e, stageMatrix.f);
                 if (typeof dataId === 'string') {
                     activeChartInstance.updateDataSync(dataId, data ?? []);
                 }
@@ -55077,13 +55193,13 @@
                 }
             }
             else {
-                if (chart.getRootNode().table.internalProps.renderChartAsync) {
+                if (table.internalProps.renderChartAsync) {
                     if (chartRenderKeys.indexOf(`${chart.parent.col}+${chart.parent.row}`) === -1) {
                         chartRenderKeys.push(`${chart.parent.col}+${chart.parent.row}`);
                         chartRenderQueueList.push(chart);
                     }
                     if (!IsHandlingChartQueue()) {
-                        startRenderChartQueue(chart.getRootNode().table);
+                        startRenderChartQueue(table);
                     }
                 }
                 else {
@@ -55092,31 +55208,7 @@
             }
         }
         draw(chart, renderService, drawContext, params) {
-            const { context } = drawContext;
-            if (!context) {
-                return;
-            }
-            const { clip } = chart.attribute;
-            if (clip) {
-                context.save();
-            }
-            else {
-                context.highPerformanceSave();
-            }
-            context.transformFromMatrix(chart.transMatrix, true);
-            context.beginPath();
-            if (params.skipDraw) {
-                this.drawShape(chart, context, 0, 0, drawContext, params, () => false, () => false);
-            }
-            else {
-                this.drawShape(chart, context, 0, 0, drawContext);
-            }
-            if (clip) {
-                context.restore();
-            }
-            else {
-                context.highPerformanceRestore();
-            }
+            this._draw(chart, {}, false, drawContext, params);
         }
     };
     DefaultCanvasChartRender = __decorate([
@@ -59967,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);
                 }
             }
         }
@@ -60044,6 +60214,15 @@
             });
         }
     }
+    function clearCellChartCacheImage(col, row, scenegraph) {
+        const cellGroup = scenegraph.getCell(col, row);
+        cellGroup.children.forEach((node) => {
+            if (node.type === 'chart') {
+                node.cacheCanvas = null;
+                node.addUpdateBoundTag();
+            }
+        });
+    }
     function updateChartData(scenegraph) {
         const table = scenegraph.table;
         for (let c = scenegraph.proxy.colStart; c <= scenegraph.proxy.colEnd; c++) {
@@ -60134,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;
@@ -60905,7 +61095,12 @@
             setPoptipTheme(this.table.theme.textPopTipStyle);
             let width;
             let height;
-            if (Env.mode === 'node') {
+            if (table.options.canvas && table.options.viewBox) {
+                vglobal.setEnv('browser');
+                width = table.options.viewBox.x2 - table.options.viewBox.x1;
+                height = table.options.viewBox.y2 - table.options.viewBox.y1;
+            }
+            else if (Env.mode === 'node') {
                 vglobal.setEnv('node', table.options.modeParams);
                 width = table.canvasWidth;
                 height = table.canvasHeight;
@@ -60923,9 +61118,15 @@
                 background: table.theme.underlayBackgroundColor,
                 dpr: table.internalProps.pixelRatio,
                 enableLayout: true,
-                afterRender: () => {
+                beforeRender: (stage) => {
+                    this.table.options.beforeRender && this.table.options.beforeRender(stage);
+                },
+                afterRender: (stage) => {
+                    this.table.options.afterRender && this.table.options.afterRender(stage);
                     this.table.fireListeners('after_render', null);
                 },
+                canvasControled: !table.options.canvas,
+                viewBox: table.options.viewBox,
                 ...table.options.renderOption
             });
             this.stage.defaultLayer.setTheme({
@@ -61301,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);
@@ -61438,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();
@@ -63706,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);
@@ -64193,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();
         }
@@ -66243,20 +66444,22 @@
                 e.preventDefault();
             }
         });
-        handler.on(table.getContainer(), 'resize', e => {
-            if (e.width === 0 && e.height === 0) {
-                return;
-            }
-            if (table.autoFillWidth || table.autoFillHeight) {
-                table.editorManager?.completeEdit();
-            }
-            if (!isValid$1(table.options.pixelRatio)) {
-                table.setPixelRatio(getPixelRatio());
-            }
-            if (!e.windowSizeNotChange) {
-                table.resize();
-            }
-        });
+        if (!table.options.canvas) {
+            handler.on(table.getContainer(), 'resize', e => {
+                if (e.width === 0 && e.height === 0) {
+                    return;
+                }
+                if (table.autoFillWidth || table.autoFillHeight) {
+                    table.editorManager?.completeEdit();
+                }
+                if (!isValid$1(table.options.pixelRatio)) {
+                    table.setPixelRatio(getPixelRatio());
+                }
+                if (!e.windowSizeNotChange) {
+                    table.resize();
+                }
+            });
+        }
         const regex = /<tr[^>]*>([\s\S]*?)<\/tr>/g;
         const cellRegex = /<td[^>]*>([\s\S]*?)<\/td>/g;
         function pasteHtmlToTable(item) {
@@ -66818,7 +67021,7 @@
             this.table = table;
             this.handleTextStickBindId = [];
             this.inertiaScroll = new InertiaScroll(table.stateManager);
-            if (Env.mode === 'node') {
+            if (Env.mode === 'node' || table.options.disableInteraction) {
                 return;
             }
             this.bindOuterEvent();
@@ -68419,6 +68622,7 @@
     }
 
     class FocusInput extends EventTarget {
+        _container;
         _table;
         _input;
         constructor(table, parentElement) {
@@ -68438,6 +68642,7 @@
             input.dataset.vtable = 'vtable';
             input.readOnly = true;
             parentElement.appendChild(div);
+            this._container = div;
         }
         focus() {
             this._input.focus({ preventScroll: true });
@@ -68457,6 +68662,7 @@
             return this._input;
         }
         release() {
+            this._container.parentElement?.removeChild(this._container);
         }
     }
 
@@ -70606,7 +70812,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.5.5";
+        version = "1.5.6";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -70621,7 +70827,7 @@
         _hasAutoImageColumn;
         constructor(container, options = {}) {
             super();
-            if (!container && options.mode !== 'node') {
+            if (!container && options.mode !== 'node' && !options.canvas) {
                 throw new Error("vtable's container is undefined");
             }
             const { frozenColCount = 0, frozenRowCount, defaultRowHeight = 40, defaultHeaderRowHeight, defaultColWidth = 80, defaultHeaderColWidth, widthMode = 'standard', heightMode = 'standard', autoFillWidth = false, autoFillHeight = false, widthAdaptiveMode = 'only-body', heightAdaptiveMode = 'only-body', keyboardOptions, eventOptions, rowSeriesNumber, columnResizeMode, rowResizeMode = 'none', dragHeaderMode, showFrozenIcon, allowFrozenColCount, padding, hover, menu, select: click, customRender, pixelRatio = defaultPixelRatio, renderChartAsync, renderChartAsyncBatchCount, mode, modeParams, canvasWidth, canvasHeight, overscrollBehavior, limitMinWidth, limitMinHeight, clearDOM = true } = options;
@@ -70659,7 +70865,14 @@
             if (typeof allowFrozenColCount === 'number' && allowFrozenColCount <= 0) {
                 this.showFrozenIcon = false;
             }
-            if (Env.mode !== 'node') {
+            if (this.options.canvas) {
+                internalProps.element = this.options.canvas.parentElement;
+                internalProps.element.style.position = 'relative';
+                internalProps.focusControl = new FocusInput(this, internalProps.element);
+                internalProps.canvas = this.options.canvas;
+                internalProps.context = internalProps.canvas.getContext('2d');
+            }
+            else if (Env.mode !== 'node') {
                 internalProps.element = createRootElement(this.padding);
                 internalProps.focusControl = new FocusInput(this, internalProps.element);
                 internalProps.canvas = document.createElement('canvas');
@@ -71067,7 +71280,21 @@
             const { padding } = this;
             let widthP = 0;
             let heightP = 0;
-            if (Env.mode === 'browser') {
+            this.tableX = 0;
+            this.tableY = 0;
+            if (this.options.canvas && this.options.viewBox) {
+                widthP = this.options.viewBox.x2 - this.options.viewBox.x1;
+                heightP = this.options.viewBox.y2 - this.options.viewBox.y1;
+                if (this?.scenegraph?.stage) {
+                    if (this.options.viewBox) {
+                        this.scenegraph.stage.setViewBox(this.options.viewBox, false);
+                    }
+                    else {
+                        this.scenegraph.stage.resize(widthP, heightP);
+                    }
+                }
+            }
+            else if (Env.mode === 'browser') {
                 const element = this.getElement();
                 let widthWithoutPadding = 0;
                 let heightWithoutPadding = 0;
@@ -71134,6 +71361,23 @@
                 }
             }
         }
+        updateViewBox(newViewBox) {
+            const oldWidth = this.options?.viewBox.x2 ?? 0 - this.options?.viewBox.x1 ?? 0;
+            const oldHeight = this.options?.viewBox.y2 ?? 0 - this.options?.viewBox.y1 ?? 0;
+            const newWidth = newViewBox.x2 - newViewBox.x1;
+            const newHeight = newViewBox.y2 - newViewBox.y1;
+            this.options.viewBox = newViewBox;
+            if (oldWidth !== newWidth || oldHeight !== newHeight) {
+                this.resize();
+            }
+            else {
+                this.scenegraph.stage.setViewBox(this.options.viewBox, true);
+            }
+        }
+        setViewBoxTransform(a, b, c, d, e, f) {
+            this.internalProps.modifiedViewBoxTransform = true;
+            this.scenegraph.stage.window.setViewBoxTransform(a, b, c, d, e, f);
+        }
         get rowHierarchyType() {
             return 'grid';
         }
@@ -71660,6 +71904,8 @@
             const visibleRect = this.getVisibleRect();
             rect.offsetLeft(this.tableX - (relativeX ? visibleRect.left : 0));
             rect.offsetTop(this.tableY - (relativeY ? visibleRect.top : 0));
+            rect.offsetLeft(this.options.viewBox?.x1 ?? 0);
+            rect.offsetTop(this.options.viewBox?.y1 ?? 0);
             return rect;
         }
         getVisibleRect() {
@@ -71819,8 +72065,9 @@
             }
             this.scenegraph.stage.release();
             this.scenegraph.proxy.release();
+            internalProps.focusControl.release();
             const { parentElement } = internalProps.element;
-            if (parentElement) {
+            if (parentElement && !this.options.canvas) {
                 parentElement.removeChild(internalProps.element);
             }
             this.editorManager?.editingEditor?.onEnd?.();
@@ -71864,7 +72111,7 @@
             this.autoFillHeight = autoFillHeight ?? false;
             this.customRender = customRender;
             const internalProps = this.internalProps;
-            if (Env.mode !== 'node') {
+            if (Env.mode !== 'node' && !options.canvas) {
                 updateRootElementPadding(internalProps.element, this.padding);
             }
             this.columnWidthComputeMode = options.columnWidthComputeMode ?? 'normal';
@@ -72045,9 +72292,14 @@
             const currentHeight = rect.height;
             const originHeight = this.canvas.offsetHeight || currentHeight;
             const heightRatio = currentHeight / originHeight;
-            const x = (clientX - rect.left) / widthRatio + (isAddScroll ? table.scrollLeft : 0);
-            const y = (clientY - rect.top) / heightRatio + (isAddScroll ? table.scrollTop : 0);
-            return { x, y, inTable };
+            const x = (clientX - rect.left) / widthRatio + (isAddScroll ? table.scrollLeft : 0) - (this.options.viewBox?.x1 ?? 0);
+            const y = (clientY - rect.top) / heightRatio + (isAddScroll ? table.scrollTop : 0) - (this.options.viewBox?.y1 ?? 0);
+            const point = { x, y, inTable };
+            if (this.internalProps.modifiedViewBoxTransform && this.scenegraph.stage.window.getViewBoxTransform()) {
+                const transform = this.scenegraph.stage.window.getViewBoxTransform();
+                transform.transformPoint(point, point);
+            }
+            return point;
         }
         getTheme() {
             return this.internalProps.theme;
@@ -76369,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);
                 }
             }
         }
@@ -77686,7 +77938,9 @@
             const axisStylrAttrs = getAxisAttributes(this.option);
             const attrs = this.getUpdateAttribute();
             attrs.verticalFactor = this.orient === 'top' || this.orient === 'right' ? -1 : 1;
-            this.component = new LineAxis(merge({}, axisStylrAttrs, attrs));
+            this.component = new LineAxis(merge({
+                disableTriggerEvent: this.table.options.disableInteraction
+            }, axisStylrAttrs, attrs));
             this.component.setAttributes(this.setLayoutStartPosition({ x: 0, y: 0 }));
             this.component.originAxis = this;
         }
@@ -78267,7 +78521,8 @@
                 height: this.table.tableNoFrameHeight
             });
             const legend = new DiscreteLegend(merge({}, attrs, {
-                defaultSelected: this.selectedData
+                defaultSelected: this.selectedData,
+                disableTriggerEvent: this.table.options.disableInteraction
             }));
             legend.name = 'legend';
             this.legendComponent = legend;
@@ -79967,7 +80222,8 @@
             data: table.getCellValue(col, row),
             cellPadding: padding,
             dpr: table.internalProps.pixelRatio,
-            axes: table.isPivotChart() ? table.internalProps.layoutMap.getChartAxes(col, row) : []
+            axes: table.isPivotChart() ? table.internalProps.layoutMap.getChartAxes(col, row) : [],
+            tableChartOption: table.options.chartOption
         });
         cellGroup.appendChild(chartGroup);
         table.internalProps.layoutMap.setChartInstance(col, row, chartGroup.chartInstance);
@@ -87017,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);
                 }
             }
         }
@@ -88316,6 +88572,14 @@
             updateChartData(this.scenegraph);
             this.render();
         }
+        clearChartCacheImage(col, row) {
+            if (isNumber$2(col) && isNumber$2(row)) {
+                clearCellChartCacheImage(col, row, this.scenegraph);
+            }
+            else {
+                clearChartCacheImage(this.scenegraph);
+            }
+        }
         getLegendSelected() {
             const selected = [];
             this.internalProps.legends?.forEach(legend => {
@@ -89109,7 +89373,7 @@
     }
 
     registerForVrender();
-    const version = "1.5.5";
+    const version = "1.5.6";
     function getIcons() {
         return get$2();
     }