@visactor/vtable 1.5.2-alpha.0 → 1.5.2

package/dist/vtable.js

@@ -47405,7 +47405,7 @@
                 const dataIndex = this.getIndexKey(index);
                 if (!this.beforeChangedRecordsMap[dataIndex]) {
                     const originRecord = this.getOriginalRecord(dataIndex);
-                    this.beforeChangedRecordsMap[dataIndex] = cloneDeep(originRecord);
+                    this.beforeChangedRecordsMap[dataIndex] = cloneDeep(originRecord) ?? {};
                 }
                 if (typeof field === 'string' || typeof field === 'number') {
                     const beforeChangedValue = this.beforeChangedRecordsMap[dataIndex][field];
@@ -47423,7 +47423,13 @@
                         });
                     }
                     else {
-                        record[field] = formatValue;
+                        if (record) {
+                            record[field] = formatValue;
+                        }
+                        else {
+                            this.records[dataIndex] = {};
+                            this.records[dataIndex][field] = formatValue;
+                        }
                     }
                 }
             }
@@ -48913,60 +48919,188 @@
             this.headerCustomLayoutFuncCache = new Map();
             this.headerReactRemoveGraphicCache = new Map();
         }
-        hasReactCreateGraphic(componentIndex, isHeaderCustomLayout) {
+        hasReactCreateGraphic(componentId, isHeaderCustomLayout) {
             if (isHeaderCustomLayout) {
-                return this.headerCustomLayoutFuncCache.has(componentIndex);
+                return this.headerCustomLayoutFuncCache.has(componentId);
             }
-            return this.customLayoutFuncCache.has(componentIndex);
+            return this.customLayoutFuncCache.has(componentId);
         }
-        setReactCreateGraphic(componentIndex, createGraphic, isHeaderCustomLayout) {
+        setReactCreateGraphic(componentId, createGraphic, isHeaderCustomLayout) {
             if (isHeaderCustomLayout) {
-                this.headerCustomLayoutFuncCache.set(componentIndex, createGraphic);
+                this.headerCustomLayoutFuncCache.set(componentId, createGraphic);
             }
             else {
-                this.customLayoutFuncCache.set(componentIndex, createGraphic);
+                this.customLayoutFuncCache.set(componentId, createGraphic);
             }
         }
-        setReactRemoveGraphic(componentIndex, removeGraphic, isHeaderCustomLayout) {
+        setReactRemoveGraphic(componentId, removeGraphic, isHeaderCustomLayout) {
             if (isHeaderCustomLayout) {
-                this.headerReactRemoveGraphicCache.set(componentIndex, removeGraphic);
+                this.headerReactRemoveGraphicCache.set(componentId, removeGraphic);
             }
             else {
-                this.reactRemoveGraphicCache.set(componentIndex, removeGraphic);
+                this.reactRemoveGraphicCache.set(componentId, removeGraphic);
             }
         }
-        updateCustomCell(componentIndex, isHeaderCustomLayout) {
+        updateCustomCell(componentId, isHeaderCustomLayout) {
             const table = this.table;
-            const col = componentIndex;
-            if (isHeaderCustomLayout) {
-                for (let row = 0; row < table.columnHeaderLevelCount; row++) {
-                    table.scenegraph.updateCellContent(col, row);
+            if (table.isPivotTable()) {
+                const ranges = getUpdateCustomCellRangeInPivotTable(componentId, table, isHeaderCustomLayout);
+                for (let i = 0; i < ranges.length; i++) {
+                    const range = ranges[i];
+                    for (let col = range.start.col; col <= range.end.col; col++) {
+                        for (let row = range.start.row; row <= range.end.row; row++) {
+                            table.scenegraph.updateCellContent(col, row);
+                        }
+                    }
                 }
             }
             else {
-                for (let row = table.columnHeaderLevelCount; row < table.rowCount; row++) {
-                    table.scenegraph.updateCellContent(col, row);
+                const range = getUpdateCustomCellRangeInListTable(componentId, table, isHeaderCustomLayout);
+                for (let col = range.start.col; col <= range.end.col; col++) {
+                    for (let row = range.start.row; row <= range.end.row; row++) {
+                        table.scenegraph.updateCellContent(col, row);
+                    }
                 }
             }
             table.scenegraph.renderSceneGraph();
         }
         getCustomLayoutFunc(col, row) {
-            const { startInTotal } = this.table.getBodyColumnDefine(col, row);
             const isHeader = this.table.isHeader(col, row);
-            return ((isHeader ? this.headerCustomLayoutFuncCache.get(startInTotal) : this.customLayoutFuncCache.get(startInTotal)) ||
-                emptyCustomLayout);
+            if (isHeader) {
+                const { componentId } = this.table.getHeaderDefine(col, row);
+                return this.headerCustomLayoutFuncCache.get(componentId) ?? emptyCustomLayout;
+            }
+            const { componentId } = this.table.getBodyColumnDefine(col, row);
+            return this.customLayoutFuncCache.get(componentId) || emptyCustomLayout;
         }
         removeCustomCell(col, row) {
-            const { startInTotal } = this.table.getBodyColumnDefine(col, row);
             const isHeader = this.table.isHeader(col, row);
-            const removeFun = isHeader
-                ? this.headerReactRemoveGraphicCache.get(startInTotal)
-                : this.reactRemoveGraphicCache.get(startInTotal);
+            let removeFun;
+            if (isHeader) {
+                const define = this.table.getHeaderDefine(col, row);
+                const { componentId } = define;
+                removeFun = this.headerReactRemoveGraphicCache.get(componentId);
+            }
+            else {
+                const define = this.table.getBodyColumnDefine(col, row);
+                const { componentId } = define;
+                removeFun = this.reactRemoveGraphicCache.get(componentId);
+            }
             if (removeFun) {
                 removeFun(col, row);
             }
         }
     }
+    function getUpdateCustomCellRangeInListTable(componentId, table, isHeaderCustomLayout) {
+        const rowSeriesNumber = table.internalProps.rowSeriesNumber ? 1 : 0;
+        if (isHeaderCustomLayout) {
+            const layoutMap = table.internalProps.layoutMap;
+            const { headerObjects } = table.internalProps.layoutMap;
+            let headerId;
+            for (let i = 0; i < headerObjects.length; i++) {
+                const headerObject = headerObjects[i];
+                if (headerObject.define.componentId === componentId) {
+                    headerId = headerObject.id;
+                    break;
+                }
+            }
+            const startCell = layoutMap.getHeaderCellAdressById(headerId);
+            const range = layoutMap.getCellRange(startCell.col, startCell.row);
+            return range;
+        }
+        const { columnObjects } = table.internalProps.layoutMap;
+        for (let i = 0; i < columnObjects.length; i++) {
+            const columnObject = columnObjects[i];
+            if (columnObject.define.componentId === componentId) {
+                return {
+                    start: {
+                        col: rowSeriesNumber + i,
+                        row: table.columnHeaderLevelCount
+                    },
+                    end: {
+                        col: rowSeriesNumber + i,
+                        row: table.rowCount - 1
+                    }
+                };
+            }
+        }
+        return {
+            start: {
+                col: 0,
+                row: 0
+            },
+            end: {
+                col: table.colCount - 1,
+                row: table.rowCount - 1
+            }
+        };
+    }
+    function getUpdateCustomCellRangeInPivotTable(componentId, table, isHeaderCustomLayout) {
+        const rowSeriesNumber = table.internalProps.rowSeriesNumber ? 1 : 0;
+        const ranges = [];
+        const layoutMap = table.internalProps.layoutMap;
+        if (isHeaderCustomLayout) {
+            const { headerObjects } = layoutMap;
+            const headerIds = [];
+            for (let i = 0; i < headerObjects.length; i++) {
+                const headerObject = headerObjects[i];
+                if (!headerObject) {
+                    continue;
+                }
+                if (headerObject.define.componentId === componentId) {
+                    headerIds.push(headerObject.id);
+                }
+            }
+            for (let i = 0; i < headerIds.length; i++) {
+                const headerId = headerIds[i];
+                const startCell = layoutMap.getHeaderCellAdressById(headerId);
+                const range = layoutMap.getCellRange(startCell.col, startCell.row);
+                ranges.push(range);
+            }
+        }
+        else {
+            let columnIndex;
+            const { columnObjects, indicatorsAsCol } = layoutMap;
+            for (let i = 0; i < columnObjects.length; i++) {
+                const columnObject = columnObjects[i];
+                if (columnObject.define.componentId === componentId) {
+                    columnIndex = i;
+                    break;
+                }
+            }
+            if (indicatorsAsCol) {
+                for (let column = layoutMap.rowHeaderLevelCount + columnIndex; column < layoutMap.colCount; column += columnObjects.length) {
+                    const range = {
+                        start: {
+                            col: column + rowSeriesNumber,
+                            row: layoutMap.columnHeaderLevelCount
+                        },
+                        end: {
+                            col: column + rowSeriesNumber,
+                            row: layoutMap.rowCount - 1
+                        }
+                    };
+                    ranges.push(range);
+                }
+            }
+            else {
+                for (let row = layoutMap.columnHeaderLevelCount + columnIndex; row < layoutMap.rowCount; row += columnObjects.length) {
+                    const range = {
+                        start: {
+                            col: layoutMap.rowHeaderLevelCount + rowSeriesNumber,
+                            row: row
+                        },
+                        end: {
+                            col: layoutMap.colCount - 1,
+                            row: row
+                        }
+                    };
+                    ranges.push(range);
+                }
+            }
+        }
+        return ranges;
+    }
 
     function getCellEventArgsSet(e) {
         const tableEvent = {
@@ -49409,6 +49543,9 @@
             return;
         }
         const cellGroup = getTargetCell(graphic);
+        if (!cellGroup || cellGroup.stage) {
+            return;
+        }
         const table = cellGroup.stage.table;
         graphic.skipAttributeUpdate = true;
         const { mergeStartCol, mergeEndCol, mergeStartRow, mergeEndRow } = cellGroup;
@@ -50316,6 +50453,11 @@
         while (text.length && text.length > 1 && !text[text.length - 1]) {
             text.pop();
         }
+        if (table.options.customConfig?.multilinesForXTable && !table.internalProps.autoWrapText) {
+            while (text.length && text.length > 1 && !text[0]) {
+                text.shift();
+            }
+        }
         return {
             text,
             moreThanMaxCharacters
@@ -51393,9 +51535,9 @@
             colForDefine = range.start.col;
             rowForDefine = range.start.row;
         }
-        const define = cellLocation !== 'body'
+        const define = (cellLocation !== 'body'
             ? table.getHeaderDefine(colForDefine, rowForDefine)
-            : table.getBodyColumnDefine(colForDefine, rowForDefine);
+            : table.getBodyColumnDefine(colForDefine, rowForDefine));
         if (!range && (cellLocation !== 'body' || define?.mergeCell)) {
             range = table.getCellRange(col, row);
             isMerge = range.start.col !== range.end.col || range.start.row !== range.end.row;
@@ -51404,7 +51546,10 @@
             cellTheme = getStyleTheme(cellStyle, table, isMerge ? range.start.col : col, isMerge ? range.start.row : row, getProp).theme;
         }
         cellTheme.group.cornerRadius = getCellCornerRadius(col, row, table);
-        if (!addNew && !isMerge && canUseFastUpdate(col, row, oldCellGroup, autoWrapText, table)) {
+        if (!addNew &&
+            !isMerge &&
+            !(define.customLayout || define.customRender || define.headerCustomLayout || define.headerCustomRender) &&
+            canUseFastUpdate(col, row, oldCellGroup, autoWrapText, table)) {
             const cellWidth = table.getColWidth(col);
             const cellHeight = table.getRowHeight(row);
             oldCellGroup.setAttributes({
@@ -51526,8 +51671,10 @@
         if (!addNew && oldCellGroup.parent) {
             if (table.reactCustomLayout) {
                 const reactGroup = oldCellGroup.getChildByName('custom-container');
-                const { col, row } = reactGroup;
-                table.reactCustomLayout.removeCustomCell(col, row);
+                if (reactGroup) {
+                    const { col, row } = reactGroup;
+                    table.reactCustomLayout.removeCustomCell(col, row);
+                }
             }
         }
         const newCellGroup = createCell(type, value, define, table, col, row, table.getColWidth(col), cellWidth, cellHeight, addNew ? table.scenegraph.getColGroup(col) : oldCellGroup.parent, addNew ? 0 : table.scenegraph.getCellGroupY(row), padding, textAlign, textBaseline, mayHaveIcon, cellTheme, range, customResult);
@@ -51964,6 +52111,11 @@
                 oldRowHeights[row] = table.getRowHeight(row);
             }
         }
+        const layoutMap = table.internalProps.layoutMap;
+        if (table.isPivotTable()) {
+            layoutMap.enableUseGetBodyCache();
+            layoutMap.enableUseHeaderPathCache();
+        }
         table.defaultHeaderRowHeight;
         table.defaultHeaderColWidth;
         const isDefaultHeaderHasAuto = table.defaultHeaderRowHeight === 'auto' ||
@@ -52077,7 +52229,7 @@
             }
             let actualHeight = 0;
             for (let row = startRow; row < endRow; row++) {
-                actualHeight += update ? newHeights[row] : table.getRowHeight(row);
+                actualHeight += update ? newHeights[row] ?? table.getRowHeight(row) : table.getRowHeight(row);
             }
             const factor = totalDrawHeight / actualHeight;
             for (let row = startRow; row < endRow; row++) {
@@ -52095,7 +52247,7 @@
                                 : table.getRowsHeight(startRow, endRow - 2));
                 }
                 else {
-                    rowHeight = Math.round((update ? newHeights[row] : table.getRowHeight(row)) * factor);
+                    rowHeight = Math.round((update ? newHeights[row] ?? table.getRowHeight(row) : table.getRowHeight(row)) * factor);
                 }
                 if (update) {
                     newHeights[row] = rowHeight;
@@ -52139,7 +52291,7 @@
                                     : table.getRowsHeight(startRow, endRow - 2));
                     }
                     else {
-                        rowHeight = Math.round((update ? newHeights[row] : table.getRowHeight(row)) * factor);
+                        rowHeight = Math.round((update ? newHeights[row] ?? table.getRowHeight(row) : table.getRowHeight(row)) * factor);
                     }
                     if (update) {
                         newHeights[row] = rowHeight;
@@ -52153,7 +52305,7 @@
         if (update) {
             for (let row = rowStart; row <= rowEnd; row++) {
                 const newRowHeight = newHeights[row] ?? table.getRowHeight(row);
-                if (newRowHeight !== oldRowHeights[row]) {
+                if (newRowHeight !== (oldRowHeights[row] ?? table.getRowHeight(row))) {
                     table._setRowHeight(row, newRowHeight);
                 }
             }
@@ -52161,24 +52313,28 @@
                 (table.autoFillHeight && table.getAllRowsHeight() <= table.tableNoFrameHeight)) {
                 for (let row = 0; row <= table.columnHeaderLevelCount - 1; row++) {
                     const newRowHeight = table.getRowHeight(row);
-                    if (newRowHeight !== oldRowHeights[row]) {
-                        table.scenegraph.updateRowHeight(row, newRowHeight - oldRowHeights[row], true);
+                    if (newRowHeight !== (oldRowHeights[row] ?? table.getRowHeight(row))) {
+                        table.scenegraph.updateRowHeight(row, newRowHeight - (oldRowHeights[row] ?? table.getRowHeight(row)), true);
                     }
                 }
                 for (let row = table.rowCount - table.bottomFrozenRowCount; row <= table.rowCount - 1; row++) {
                     const newRowHeight = table.getRowHeight(row);
-                    if (newRowHeight !== oldRowHeights[row]) {
-                        table.scenegraph.updateRowHeight(row, newRowHeight - oldRowHeights[row], true);
+                    if (newRowHeight !== (oldRowHeights[row] ?? table.getRowHeight(row))) {
+                        table.scenegraph.updateRowHeight(row, newRowHeight - (oldRowHeights[row] ?? table.getRowHeight(row)), true);
                     }
                 }
             }
             for (let row = table.scenegraph.proxy.rowStart; row <= table.scenegraph.proxy.rowEnd; row++) {
                 const newRowHeight = table.getRowHeight(row);
-                if (newRowHeight !== oldRowHeights[row]) {
-                    table.scenegraph.updateRowHeight(row, newRowHeight - oldRowHeights[row], true);
+                if (newRowHeight !== (oldRowHeights[row] ?? table.getRowHeight(row))) {
+                    table.scenegraph.updateRowHeight(row, newRowHeight - (oldRowHeights[row] ?? table.getRowHeight(row)), true);
                 }
             }
         }
+        if (table.isPivotTable()) {
+            layoutMap.disableUseGetBodyCache();
+            layoutMap.disableUseHeaderPathCache();
+        }
     }
     function computeRowHeight(row, startCol, endCol, table) {
         let maxHeight;
@@ -52656,6 +52812,9 @@
             const customContainer = cell.getChildByName(CUSTOM_CONTAINER_NAME) ||
                 cell.getChildByName(CUSTOM_MERGE_CONTAINER_NAME);
             if (customContainer) {
+                if (scene.table.reactCustomLayout) {
+                    scene.table.reactCustomLayout.removeCustomCell(col, row);
+                }
                 let customElementsGroup;
                 customContainer.removeAllChild();
                 cell.removeChild(customContainer);
@@ -52986,6 +53145,9 @@
             const customContainer = cell.getChildByName(CUSTOM_CONTAINER_NAME) ||
                 cell.getChildByName(CUSTOM_MERGE_CONTAINER_NAME);
             if (customContainer) {
+                if (scene.table.reactCustomLayout) {
+                    scene.table.reactCustomLayout.removeCustomCell(col, row);
+                }
                 let customElementsGroup;
                 customContainer.removeAllChild();
                 cell.removeChild(customContainer);
@@ -56063,6 +56225,11 @@
         if (colStart === 0 && colEnd === table.colCount - 1) {
             table._clearColRangeWidthsMap();
         }
+        const layoutMap = table.internalProps.layoutMap;
+        if (table.isPivotTable()) {
+            layoutMap.enableUseGetBodyCache();
+            layoutMap.enableUseHeaderPathCache();
+        }
         const oldColWidths = [];
         const newWidths = [];
         if (update) {
@@ -56109,7 +56276,7 @@
             let endCol = table.colCount;
             if (table.widthAdaptiveMode === 'only-body') {
                 for (let col = 0; col < table.colCount; col++) {
-                    const colWidth = update ? newWidths[col] : table.getColWidth(col);
+                    const colWidth = update ? newWidths[col] ?? table.getColWidth(col) : table.getColWidth(col);
                     if (col < table.rowHeaderLevelCount ||
                         (table.isPivotChart() && col >= table.colCount - table.rightFrozenColCount)) {
                         actualHeaderWidth += colWidth;
@@ -56126,7 +56293,7 @@
             let actualHeaderWidth = 0;
             let actualWidth = 0;
             for (let col = 0; col < table.colCount; col++) {
-                const colWidth = update ? newWidths[col] : table.getColWidth(col);
+                const colWidth = update ? newWidths[col] ?? table.getColWidth(col) : table.getColWidth(col);
                 if (col < table.rowHeaderLevelCount ||
                     (table.isPivotChart() && col >= table.colCount - table.rightFrozenColCount)) {
                     actualHeaderWidth += colWidth;
@@ -56141,7 +56308,7 @@
         }
         if (update) {
             for (let col = 0; col < table.colCount; col++) {
-                const newColWidth = newWidths[col] ?? table.getColWidth(col);
+                const newColWidth = newWidths[col] ?? table.getColWidth(col) ?? table.getColWidth(col);
                 if (newColWidth !== oldColWidths[col]) {
                     table._setColWidth(col, newColWidth, false, true);
                 }
@@ -56155,6 +56322,10 @@
             }
             table.scenegraph.updateContainer(true);
         }
+        if (table.isPivotTable()) {
+            layoutMap.disableUseGetBodyCache();
+            layoutMap.disableUseHeaderPathCache();
+        }
     }
     function computeColWidth(col, startRow, endRow, table, forceCompute = false) {
         let width = getColWidthDefinedWidthResizedWidth(col, table);
@@ -56251,7 +56422,7 @@
                     }
                 }
             }
-            else {
+            else if (table.isListTable()) {
                 deltaRow = prepareDeltaRow;
                 const define = table.getBodyColumnDefine(col, row);
                 if (define?.tree) {
@@ -56412,7 +56583,7 @@
             text = cellValue;
         }
         const lines = breakString(text, table).text;
-        if (lines.length >= 1) {
+        if (lines.length >= 1 && !(lines.length === 1 && lines[0] === '')) {
             lines.forEach((line) => {
                 const width = table.measureText(line, {
                     fontSize,
@@ -56486,7 +56657,7 @@
         const sparklineColumns = [];
         let totalSparklineAbleWidth = 0;
         for (let col = startCol; col < endColPlus1; col++) {
-            const width = update ? newWidths[col] : table.getColWidth(col);
+            const width = update ? newWidths[col] ?? table.getColWidth(col) : table.getColWidth(col);
             const maxWidth = table.getMaxColWidth(col);
             const minWidth = table.getMinColWidth(col);
             if (width !== maxWidth && width !== minWidth) {
@@ -56532,13 +56703,13 @@
                     totalDrawWidth -
                         adaptiveColumns.reduce((acr, cur, index) => {
                             if (cur !== col) {
-                                return acr + (update ? newWidths[cur] : table.getColWidth(cur));
+                                return acr + (update ? newWidths[cur] ?? table.getColWidth(col) : table.getColWidth(cur));
                             }
                             return acr;
                         }, 0);
             }
             else {
-                colWidth = Math.round((update ? newWidths[col] : table.getColWidth(col)) * factor);
+                colWidth = Math.round((update ? newWidths[col] ?? table.getColWidth(col) : table.getColWidth(col)) * factor);
             }
             if (update) {
                 newWidths[col] = table._adjustColWidth(col, colWidth);
@@ -61118,11 +61289,36 @@
             }
         }
         recalculateColWidths() {
-            computeColsWidth(this.table, 0, this.table.colCount - 1, true);
+            const table = this.table;
+            if (table.widthMode === 'adaptive' || table.autoFillWidth || table.internalProps.transpose) {
+                computeColsWidth(this.table, 0, this.table.colCount - 1, true);
+            }
+            else {
+                table._clearColRangeWidthsMap();
+                if (table.frozenColCount > 0) {
+                    computeColsWidth(this.table, 0, table.frozenColCount - 1, true);
+                }
+                if (table.rightFrozenColCount > 0) {
+                    computeColsWidth(this.table, table.rightFrozenColCount, table.colCount - 1, true);
+                }
+                computeColsWidth(table, this.proxy.colStart, this.proxy.colEnd, true);
+            }
         }
         recalculateRowHeights() {
-            this.table.internalProps.useOneRowHeightFillAll = false;
-            computeRowsHeight(this.table, 0, this.table.rowCount - 1, true, true);
+            const table = this.table;
+            table.internalProps.useOneRowHeightFillAll = false;
+            if (table.heightMode === 'adaptive' || table.autoFillHeight) {
+                computeRowsHeight(this.table, 0, this.table.rowCount - 1, true, true);
+            }
+            else {
+                if (table.frozenRowCount > 0) {
+                    computeRowsHeight(this.table, 0, table.frozenRowCount - 1, true, true);
+                }
+                if (table.bottomFrozenRowCount > 0) {
+                    computeRowsHeight(this.table, table.bottomFrozenRowCount, table.rowCount - 1, true, true);
+                }
+                computeRowsHeight(table, this.proxy.rowStart, this.proxy.rowEnd, true, true);
+            }
         }
         resize() {
             this.proxy.resize();
@@ -65652,7 +65848,9 @@
             eventManager.dealTableHover();
         });
         handler.on(table.getElement(), 'wheel', (e) => {
-            handleWhell(e, stateManager);
+            if (table.eventManager._enableTableScroll) {
+                handleWhell(e, stateManager);
+            }
         });
         handler.on(table.getElement(), 'keydown', (e) => {
             if (e.key === 'a' && (e.ctrlKey || e.metaKey)) {
@@ -66119,7 +66317,10 @@
                 }
             }
             const isSelecting = table.stateManager.isSelecting();
-            if (eventManager.isDraging && isSelecting && table.stateManager.select.ranges?.length > 0) {
+            if (eventManager._enableTableScroll &&
+                eventManager.isDraging &&
+                isSelecting &&
+                table.stateManager.select.ranges?.length > 0) {
                 const drawRange = table.getDrawRange();
                 const topFrozenRowHeight = table.getFrozenRowsHeight();
                 const bottomFrozenRowHeight = table.getBottomFrozenRowsHeight();
@@ -66257,16 +66458,18 @@
                     y: e.changedTouches[0].pageY,
                     timestamp: Date.now()
                 });
-                const deltaX = -eventManager.touchMovePoints[eventManager.touchMovePoints.length - 1].x +
-                    eventManager.touchMovePoints[eventManager.touchMovePoints.length - 2].x;
-                const deltaY = -eventManager.touchMovePoints[eventManager.touchMovePoints.length - 1].y +
-                    eventManager.touchMovePoints[eventManager.touchMovePoints.length - 2].y;
-                handleWhell({ deltaX, deltaY }, stateManager);
-                if (e.cancelable &&
-                    (table.internalProps.overscrollBehavior === 'none' ||
-                        (Math.abs(deltaY) >= Math.abs(deltaX) && deltaY !== 0 && isVerticalScrollable(deltaY, stateManager)) ||
-                        (Math.abs(deltaY) <= Math.abs(deltaX) && deltaX !== 0 && isHorizontalScrollable(deltaX, stateManager)))) {
-                    e.preventDefault();
+                if (eventManager._enableTableScroll) {
+                    const deltaX = -eventManager.touchMovePoints[eventManager.touchMovePoints.length - 1].x +
+                        eventManager.touchMovePoints[eventManager.touchMovePoints.length - 2].x;
+                    const deltaY = -eventManager.touchMovePoints[eventManager.touchMovePoints.length - 1].y +
+                        eventManager.touchMovePoints[eventManager.touchMovePoints.length - 2].y;
+                    handleWhell({ deltaX, deltaY }, stateManager);
+                    if (e.cancelable &&
+                        (table.internalProps.overscrollBehavior === 'none' ||
+                            (Math.abs(deltaY) >= Math.abs(deltaX) && deltaY !== 0 && isVerticalScrollable(deltaY, stateManager)) ||
+                            (Math.abs(deltaY) <= Math.abs(deltaX) && deltaX !== 0 && isHorizontalScrollable(deltaX, stateManager)))) {
+                        e.preventDefault();
+                    }
                 }
             }
         };
@@ -66295,14 +66498,16 @@
                         y: e.changedTouches[0].pageY,
                         timestamp: Date.now()
                     });
-                    const firstPoint = eventManager.touchMovePoints[0];
-                    const lastPoint = eventManager.touchMovePoints[eventManager.touchMovePoints?.length - 1];
-                    const vX = (lastPoint.x - firstPoint.x) / (lastPoint.timestamp - firstPoint.timestamp);
-                    const vY = (lastPoint.y - firstPoint.y) / (lastPoint.timestamp - firstPoint.timestamp);
-                    eventManager.inertiaScroll.startInertia(vX, vY, 0.95);
-                    table.eventManager.inertiaScroll.setScrollHandle((dx, dy) => {
-                        handleWhell({ deltaX: -dx, deltaY: -dy }, table.stateManager);
-                    });
+                    if (eventManager._enableTableScroll) {
+                        const firstPoint = eventManager.touchMovePoints[0];
+                        const lastPoint = eventManager.touchMovePoints[eventManager.touchMovePoints?.length - 1];
+                        const vX = (lastPoint.x - firstPoint.x) / (lastPoint.timestamp - firstPoint.timestamp);
+                        const vY = (lastPoint.y - firstPoint.y) / (lastPoint.timestamp - firstPoint.timestamp);
+                        eventManager.inertiaScroll.startInertia(vX, vY, 0.95);
+                        table.eventManager.inertiaScroll.setScrollHandle((dx, dy) => {
+                            handleWhell({ deltaX: -dx, deltaY: -dy }, table.stateManager);
+                        });
+                    }
                 }
             }
             eventManager.isTouchdown = false;
@@ -66478,6 +66683,7 @@
         globalEventListeners = [];
         inertiaScroll;
         bindSparklineHoverEvent;
+        _enableTableScroll = true;
         constructor(table) {
             this.table = table;
             this.handleTextStickBindId = [];
@@ -66829,6 +67035,12 @@
             });
             this.globalEventListeners = [];
         }
+        enableScroll() {
+            this._enableTableScroll = true;
+        }
+        disableScroll() {
+            this._enableTableScroll = false;
+        }
     }
 
     let defaultStyle$1;
@@ -68435,14 +68647,14 @@
                 }
                 const spec = layout.getRawChartSpec(col + 1, row);
                 return merge({
-                    domain: chartType === 'scatter' ? undefined : Array.from(domain),
-                    range: chartType === 'scatter' ? domain : undefined,
+                    domain: axisOption?.type === 'linear' ? undefined : Array.from(domain),
+                    range: axisOption?.type === 'linear' ? domain : undefined,
                     title: {
                         autoRotate: true
                     }
                 }, axisOption, {
                     orient: 'left',
-                    type: chartType === 'scatter' ? axisOption?.type ?? 'linear' : 'band',
+                    type: axisOption?.type ?? 'band',
                     __vtableChartTheme: theme,
                     inverse: transformInverse(axisOption, (spec?.direction ?? (chartType === 'scatter' ? 'vertical' : 'horizontal')) === "horizontal")
                 });
@@ -68566,11 +68778,11 @@
                     return;
                 }
                 return merge({
-                    domain: chartType === 'scatter' ? undefined : Array.from(domain),
-                    range: chartType === 'scatter' ? domain : undefined
+                    domain: axisOption?.type === 'linear' ? undefined : Array.from(domain),
+                    range: axisOption?.type === 'linear' ? domain : undefined
                 }, axisOption, {
                     orient: 'bottom',
-                    type: chartType === 'scatter' ? axisOption?.type ?? 'linear' : 'band',
+                    type: axisOption?.type ?? 'band',
                     __vtableChartTheme: theme
                 });
             }
@@ -68817,6 +69029,44 @@
     function isXAxis$1(orient) {
         return orient === 'bottom' || orient === 'top';
     }
+    function hasLinearAxis(spec, tableAxesConfig, isHorizontal, isThisXAxis) {
+        if (!isArray$1(spec.axes) || spec.axes.length === 0) {
+            return (isHorizontal && isThisXAxis) || (!isHorizontal && !isThisXAxis);
+        }
+        for (let i = 0; i < spec.axes.length; i++) {
+            const axisSpec = spec.axes[i];
+            if (!isHorizontal && isThisXAxis && axisSpec.orient === 'bottom' && axisSpec.type === 'linear') {
+                return true;
+            }
+            if (isHorizontal && isThisXAxis && axisSpec.orient === 'bottom' && axisSpec.type !== 'linear') {
+                return true;
+            }
+            if (!isHorizontal && !isThisXAxis && axisSpec.orient === 'left' && axisSpec.type !== 'linear') {
+                return true;
+            }
+            if (isHorizontal && !isThisXAxis && axisSpec.orient === 'left' && axisSpec.type === 'linear') {
+                return true;
+            }
+        }
+        if (isArray$1(tableAxesConfig) && tableAxesConfig.length > 0) {
+            for (let i = 0; i < tableAxesConfig.length; i++) {
+                const axisSpec = tableAxesConfig[i];
+                if (!isHorizontal && isThisXAxis && axisSpec.orient === 'bottom' && axisSpec.type === 'linear') {
+                    return true;
+                }
+                if (isHorizontal && isThisXAxis && axisSpec.orient === 'bottom' && axisSpec.type !== 'linear') {
+                    return true;
+                }
+                if (!isHorizontal && !isThisXAxis && axisSpec.orient === 'left' && axisSpec.type !== 'linear') {
+                    return true;
+                }
+                if (isHorizontal && !isThisXAxis && axisSpec.orient === 'left' && axisSpec.type === 'linear') {
+                    return true;
+                }
+            }
+        }
+        return (isHorizontal && isThisXAxis) || (!isHorizontal && !isThisXAxis);
+    }
 
     class NumberRangeMap {
         data;
@@ -69586,10 +69836,10 @@
         }
         results[id] = cell;
         layoutMap._headerObjects[id] = cell;
-        _headerCellIds[row][layoutMap.colIndex] = id;
         for (let r = row - 1; r >= 0; r--) {
             _headerCellIds[r][layoutMap.colIndex] = roots[r];
         }
+        _headerCellIds[row][layoutMap.colIndex] = id;
         if (hd.levelSpan > 1) {
             for (let i = 1; i < hd.levelSpan; i++) {
                 if (!_headerCellIds[row + i]) {
@@ -70222,7 +70472,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.5.2-alpha.0";
+        version = "1.5.2";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -72925,6 +73175,12 @@
             this.scenegraph.component.hideMoveCol();
             this.scenegraph.renderSceneGraph();
         }
+        disableScroll() {
+            this.eventManager.disableScroll();
+        }
+        enableScroll() {
+            this.eventManager.enableScroll();
+        }
     }
 
     var core = /*#__PURE__*/Object.freeze({
@@ -73818,11 +74074,11 @@
             const domain = data[rowPath ?? ''];
             const { axisOption, isPercent, chartType } = getAxisOption(col, row, 'left', layout);
             axes.push(merge({
-                domain: chartType === 'scatter' && !Array.isArray(domain) ? undefined : Array.from(domain ?? []),
-                range: chartType === 'scatter' && !Array.isArray(domain) ? domain : undefined,
+                domain: axisOption?.type === 'linear' && !Array.isArray(domain) ? undefined : Array.from(domain ?? []),
+                range: axisOption?.type === 'linear' && !Array.isArray(domain) ? domain : undefined,
                 label: { style: { fontSize: DEFAULT_TEXT_FONT_SIZE } }
             }, axisOption, {
-                type: chartType === 'scatter' && !Array.isArray(domain) ? axisOption?.type ?? 'linear' : 'band',
+                type: axisOption?.type ?? 'band',
                 orient: 'left',
                 label: { visible: false },
                 domainLine: { visible: false },
@@ -73877,11 +74133,11 @@
             const domain = data?.[colPath ?? ''] ?? [];
             const { axisOption, isPercent, chartType } = getAxisOption(col, row, 'bottom', layout);
             axes.push(merge({
-                domain: chartType === 'scatter' && !Array.isArray(domain) ? undefined : Array.from(domain ?? []),
-                range: chartType === 'scatter' && !Array.isArray(domain) ? domain : undefined,
+                domain: axisOption?.type === 'linear' && !Array.isArray(domain) ? undefined : Array.from(domain ?? []),
+                range: axisOption?.type === 'linear' && !Array.isArray(domain) ? domain : undefined,
                 label: { style: { fontSize: DEFAULT_TEXT_FONT_SIZE } }
             }, axisOption, {
-                type: chartType === 'scatter' && !Array.isArray(domain) ? axisOption?.type ?? 'linear' : 'band',
+                type: axisOption?.type ?? 'band',
                 orient: 'bottom',
                 visible: true,
                 label: { visible: false },
@@ -81199,14 +81455,16 @@
         _chartPaddingOuter;
         _chartItemBandSize;
         _chartPadding;
-        _lastCellCol;
-        _lastCellRow;
-        _lastCellHeaderPath;
         rowSeriesNumberColumn;
         leftRowSeriesNumberColumn;
         leftRowSeriesNumberColumnCount = 0;
         rightRowSeriesNumberColumn;
         rightRowSeriesNumberColumnCount = 0;
+        _useGetBodyCache = false;
+        _getBodyCache = new Map();
+        _useHeaderPathCache = false;
+        _colHeaderPathCache = new Map();
+        _rowHeaderPathCache = new Map();
         constructor(table, dataset, columnDimensionTree, rowDimensionTree) {
             this.sharedVar = table.layoutNodeId;
             this._table = table;
@@ -82457,13 +82715,19 @@
             return this.getHeaderCellAdressById(hd.id);
         }
         getBody(_col, _row) {
+            const cache = this.getBodyWidthCache(_col, _row);
+            if (cache) {
+                return cache;
+            }
             if (this.isSeriesNumber(_col, _row)) {
-                return this.getSeriesNumberBody(_col, _row);
+                const body = this.getSeriesNumberBody(_col, _row);
+                this.setBodyWidthCache(_col, _row, body);
+                return body;
             }
             const paths = this.getCellHeaderPaths(_col, _row);
             if (this.indicatorsAsCol) {
                 const indicatorKey = paths.colHeaderPaths?.find(colPath => colPath.indicatorKey)?.indicatorKey;
-                return isValid$1(indicatorKey)
+                const body = isValid$1(indicatorKey)
                     ? this._indicators?.find(indicator => indicator.indicatorKey === indicatorKey) ??
                         this._indicators[0] ?? {
                         id: '',
@@ -82479,9 +82743,11 @@
                         cellType: 'text',
                         define: undefined
                     };
+                this.setBodyWidthCache(_col, _row, body);
+                return body;
             }
             const indicatorKey = paths.rowHeaderPaths?.find(rowPath => rowPath.indicatorKey)?.indicatorKey;
-            return isValid$1(indicatorKey)
+            const body = isValid$1(indicatorKey)
                 ? this._indicators?.find(indicator => indicator.indicatorKey === indicatorKey) ??
                     this._indicators[0] ?? {
                     id: '',
@@ -82497,6 +82763,8 @@
                     cellType: 'text',
                     define: undefined
                 };
+            this.setBodyWidthCache(_col, _row, body);
+            return body;
         }
         getCellRange(col, row) {
             const result = { start: { col, row }, end: { col, row } };
@@ -82628,25 +82896,24 @@
             return undefined;
         }
         getCellHeaderPathsWithTreeNode(col, row) {
-            if (col === this._lastCellCol && row === this._lastCellRow) {
-                return this._lastCellHeaderPath;
-            }
             for (let i = 0; i < this._largeCellRangeCache.length; i++) {
                 const range = this._largeCellRangeCache[i];
                 if (col >= range.start.col && col <= range.end.col && row >= range.start.row && row <= range.end.row) {
                     break;
                 }
             }
+            let colPath = this.getColHeaderPathCache(col, row);
+            let rowPath = this.getRowHeaderPathCache(col, row);
             const recordCol = this.getBodyIndexByCol(col);
             const recordRow = this.getBodyIndexByRow(row) + this.currentPageStartIndex;
-            let colPath = [];
-            let rowPath = [];
-            if (row >= 0 && recordCol >= 0) {
+            if (!colPath && row >= 0 && recordCol >= 0) {
                 colPath = this.columnDimensionTree.getTreePath(recordCol, this.showHeader && this.showColumnHeader
                     ? row - (this.columnHeaderTitle ? 1 : 0)
                     : this.columnDimensionTree.totalLevel);
+                this.setColHeaderPathCache(col, row, colPath);
             }
-            if (col >= 0 && recordRow >= 0) {
+            if (!rowPath && col >= 0 && recordRow >= 0) {
+                rowPath = [];
                 if (this.rowHierarchyType === 'tree') {
                     const row_pathIds = this._rowHeaderCellFullPathIds[recordRow];
                     let findTree = this.rowDimensionTree;
@@ -82666,7 +82933,7 @@
                             }
                         }
                         const findedRowPath = findTree.getTreePathByCellIds(pathIds);
-                        rowPath = rowPath.concat(findedRowPath);
+                        rowPath.push(...findedRowPath);
                         findTree = this._rowHeaderExtensionTree[row_pathIds[level]];
                         level++;
                     }
@@ -82676,11 +82943,9 @@
                         ? col - (this.rowHeaderTitle ? 1 : 0) - this.leftRowSeriesNumberColumnCount
                         : this.rowDimensionTree.totalLevel);
                 }
+                this.setRowHeaderPathCache(col, row, rowPath);
             }
             const p = { colHeaderPaths: colPath, rowHeaderPaths: rowPath, cellLocation: this.getCellLocation(col, row) };
-            this._lastCellHeaderPath = p;
-            this._lastCellCol = col;
-            this._lastCellRow = row;
             return p;
         }
         getCellHeaderPaths(col, row) {
@@ -83963,6 +84228,75 @@
                 }
             }
         }
+        enableUseGetBodyCache() {
+            this._useGetBodyCache = true;
+            this._getBodyCache.clear();
+        }
+        disableUseGetBodyCache() {
+            this._useGetBodyCache = false;
+            this._getBodyCache.clear();
+        }
+        enableUseHeaderPathCache() {
+            this._useHeaderPathCache = true;
+            this._colHeaderPathCache.clear();
+            this._rowHeaderPathCache.clear();
+        }
+        disableUseHeaderPathCache() {
+            this._useHeaderPathCache = false;
+            this._colHeaderPathCache.clear();
+            this._rowHeaderPathCache.clear();
+        }
+        getBodyWidthCache(col, row) {
+            if (!this._useGetBodyCache || this.isHeader(col, row) || this.isSeriesNumber(col, row)) {
+                return undefined;
+            }
+            if (this.indicatorsAsCol && this._getBodyCache.has(col)) {
+                return this._getBodyCache.get(col);
+            }
+            else if (!this.indicatorsAsCol && this._getBodyCache.has(row)) {
+                return this._getBodyCache.get(row);
+            }
+            return undefined;
+        }
+        setBodyWidthCache(col, row, cache) {
+            if (!this._useGetBodyCache || this.isHeader(col, row) || this.isSeriesNumber(col, row)) {
+                return;
+            }
+            if (this.indicatorsAsCol) {
+                this._getBodyCache.set(col, cache);
+            }
+            else {
+                this._getBodyCache.set(row, cache);
+            }
+        }
+        getColHeaderPathCache(col, row) {
+            if (this._useHeaderPathCache &&
+                !this.isHeader(col, row) &&
+                !this.isSeriesNumber(col, row) &&
+                this._colHeaderPathCache.has(col)) {
+                return this._colHeaderPathCache.get(col);
+            }
+            return undefined;
+        }
+        setColHeaderPathCache(col, row, cache) {
+            if (this._useHeaderPathCache && !this.isHeader(col, row) && !this.isSeriesNumber(col, row)) {
+                this._colHeaderPathCache.set(col, cache);
+            }
+        }
+        getRowHeaderPathCache(col, row) {
+            if (this._useHeaderPathCache &&
+                !this.isHeader(col, row) &&
+                !this.isSeriesNumber(col, row) &&
+                this._rowHeaderPathCache.has(row)) {
+                return this._rowHeaderPathCache.get(row);
+            }
+            return undefined;
+        }
+        setRowHeaderPathCache(col, row, cache) {
+            if (this._useHeaderPathCache && !this.isHeader(col, row) && !this.isSeriesNumber(col, row)) {
+                this._rowHeaderPathCache.set(row, cache);
+            }
+        }
     }
     function scaleWholeRangeSize(count, bandwidth, paddingInner, paddingOuter) {
         if (paddingInner === 1) {
@@ -84216,6 +84550,17 @@
         }
     }
 
+    function join(strArr, joinChar) {
+        let str = '';
+        for (let i = 0; i < strArr.length; i++) {
+            str += strArr[i];
+            if (i !== strArr.length - 1) {
+                str += joinChar;
+            }
+        }
+        return str;
+    }
+
     class Dataset {
         dataConfig;
         records;
@@ -84848,7 +85193,7 @@
                         }
                     });
                 }
-                flatRowKey = rowKey.join(this.stringJoinChar);
+                flatRowKey = join(rowKey, this.stringJoinChar);
             }
             if (typeof colKey === 'string') {
                 flatColKey = colKey;
@@ -84861,7 +85206,7 @@
                         }
                     });
                 }
-                flatColKey = colKey.join(this.stringJoinChar);
+                flatColKey = join(colKey, this.stringJoinChar);
             }
             const agg = this.tree[flatRowKey]?.[flatColKey]?.[indicatorIndex];
             if (considerChangedValue && isValid$1(this.changedTree[flatRowKey]?.[flatColKey]?.[indicatorIndex])) {
@@ -87633,7 +87978,7 @@
                                 collectValuesBy[xField] = {
                                     by: columnKeys,
                                     type: chartSeries.direction !== 'horizontal' ? 'xField' : undefined,
-                                    range: chartSeries.type === 'scatter' ? true : chartSeries.direction === 'horizontal',
+                                    range: hasLinearAxis(chartSeries, this._axes, chartSeries.direction === 'horizontal', true),
                                     sortBy: chartSeries.direction !== 'horizontal'
                                         ? chartSeries?.data?.fields?.[xField]?.domain ?? indicatorSpec?.data?.fields?.[xField]?.domain
                                         : undefined
@@ -87644,7 +87989,7 @@
                                     (chartSeries.stack = true);
                                 collectValuesBy[yField] = {
                                     by: rowKeys,
-                                    range: chartSeries.type === 'scatter' ? true : chartSeries.direction !== 'horizontal',
+                                    range: hasLinearAxis(chartSeries, this._axes, chartSeries.direction === 'horizontal', false),
                                     sumBy: chartSeries.stack && columnKeys.concat(chartSeries?.xField),
                                     sortBy: chartSeries.direction === 'horizontal'
                                         ? chartSeries?.data?.fields?.[yField]?.domain ?? indicatorSpec?.data?.fields?.[yField]?.domain
@@ -87658,7 +88003,7 @@
                             collectValuesBy[xField] = {
                                 by: columnKeys,
                                 type: indicatorSpec.direction !== 'horizontal' ? 'xField' : undefined,
-                                range: indicatorSpec.type === 'scatter' ? true : indicatorSpec.direction === 'horizontal',
+                                range: hasLinearAxis(indicatorSpec, this._axes, indicatorSpec.direction === 'horizontal', true),
                                 sortBy: indicatorSpec.direction !== 'horizontal' ? indicatorSpec?.data?.fields?.[xField]?.domain : undefined
                             };
                             indicatorSpec?.stack !== false &&
@@ -87690,7 +88035,7 @@
                                 collectValuesBy[yField] = {
                                     by: rowKeys,
                                     type: chartSeries.direction === 'horizontal' ? 'yField' : undefined,
-                                    range: chartSeries.type === 'scatter' ? true : chartSeries.direction !== 'horizontal',
+                                    range: hasLinearAxis(chartSeries, this._axes, chartSeries.direction === 'horizontal', false),
                                     sortBy: chartSeries.direction === 'horizontal'
                                         ? chartSeries?.data?.fields?.[yField]?.domain ?? indicatorSpec?.data?.fields?.[yField]?.domain
                                         : undefined
@@ -87701,7 +88046,7 @@
                                     (chartSeries.stack = true);
                                 collectValuesBy[xField] = {
                                     by: columnKeys,
-                                    range: chartSeries.type === 'scatter' ? true : chartSeries.direction === 'horizontal',
+                                    range: hasLinearAxis(chartSeries, this._axes, chartSeries.direction === 'horizontal', true),
                                     sumBy: chartSeries.stack && rowKeys.concat(chartSeries?.yField),
                                     sortBy: chartSeries.direction !== 'horizontal'
                                         ? chartSeries?.data?.fields?.[xField]?.domain ?? indicatorSpec?.data?.fields?.[xField]?.domain
@@ -87715,7 +88060,7 @@
                             collectValuesBy[yField] = {
                                 by: rowKeys,
                                 type: indicatorSpec.direction === 'horizontal' ? 'yField' : undefined,
-                                range: indicatorSpec.type === 'scatter' ? true : indicatorSpec.direction !== 'horizontal',
+                                range: hasLinearAxis(indicatorSpec, this._axes, indicatorSpec.direction === 'horizontal', false),
                                 sortBy: indicatorSpec.direction === 'horizontal' ? indicatorSpec?.data?.fields?.[yField]?.domain : undefined
                             };
                             indicatorSpec?.stack !== false &&
@@ -87724,7 +88069,7 @@
                             const xField = indicatorSpec.xField;
                             collectValuesBy[xField] = {
                                 by: columnKeys,
-                                range: indicatorSpec.type === 'scatter' ? true : indicatorSpec.direction === 'horizontal',
+                                range: hasLinearAxis(indicatorSpec, this._axes, indicatorSpec.direction === 'horizontal', true),
                                 sumBy: indicatorSpec.stack && rowKeys.concat(indicatorSpec?.yField),
                                 sortBy: indicatorSpec.direction !== 'horizontal' ? indicatorSpec?.data?.fields?.[xField]?.domain : undefined,
                                 extendRange: parseMarkLineGetExtendRange(indicatorSpec.markLine)
@@ -88615,7 +88960,7 @@
     }
 
     registerForVrender();
-    const version = "1.5.2-alpha.0";
+    const version = "1.5.2";
     function getIcons() {
         return get$2();
     }