@visactor/vtable 1.10.3 → 1.10.4-alpha.2

package/dist/vtable.js

@@ -33531,6 +33531,9 @@
                 this._AABBBounds.setValue(x, y, x + width, y + height);
                 this.parent && this.parent.addChildUpdateBoundTag();
                 this.clearUpdateBoundTag();
+                if (this.shadowRoot) {
+                    this.shadowRoot.tryUpdateAABBBounds();
+                }
                 return this._AABBBounds;
             }
             else if (this.role === 'body' ||
@@ -33961,12 +33964,18 @@
                     autoWrapText,
                     lineClamp,
                     wordBreak: 'break-word',
-                    heightLimit: autoRowHeight && !table.options.customConfig?.multilinesForXTable
+                    heightLimit: table.options.customConfig?.limitContentHeight === false
                         ? -1
-                        : cellHeight - Math.floor(padding[0] + padding[2]),
+                        : autoRowHeight && !table.options.customConfig?.multilinesForXTable
+                            ? -1
+                            : cellHeight - Math.floor(padding[0] + padding[2]),
                     pickable: false,
                     dx: (textAlign === 'left' ? hierarchyOffset : 0) + _contentOffset,
-                    whiteSpace: text.length === 1 && !autoWrapText ? 'no-wrap' : 'normal'
+                    whiteSpace: table.options.customConfig?.limitContentHeight === false
+                        ? 'normal'
+                        : text.length === 1 && !autoWrapText
+                            ? 'no-wrap'
+                            : 'normal'
                 };
                 const wrapText = new Text$1(cellTheme.text ? Object.assign({}, cellTheme.text, attribute) : attribute);
                 wrapText.name = 'text';
@@ -34003,14 +34012,20 @@
                         ? Infinity
                         : cellWidth - (padding[1] + padding[3]) - leftIconWidth - rightIconWidth - hierarchyOffset,
                     textBaseline: 'top',
-                    heightLimit: autoRowHeight && !table.options.customConfig?.multilinesForXTable
+                    heightLimit: table.options.customConfig?.limitContentHeight === false
                         ? -1
-                        : cellHeight - Math.floor(padding[0] + padding[2]),
+                        : autoRowHeight && !table.options.customConfig?.multilinesForXTable
+                            ? -1
+                            : cellHeight - Math.floor(padding[0] + padding[2]),
                     pickable: false,
                     autoWrapText,
                     lineClamp,
                     wordBreak: 'break-word',
-                    whiteSpace: text.length === 1 && !autoWrapText ? 'no-wrap' : 'normal',
+                    whiteSpace: table.options.customConfig?.limitContentHeight === false
+                        ? 'normal'
+                        : text.length === 1 && !autoWrapText
+                            ? 'no-wrap'
+                            : 'normal',
                     dx: (textAlign === 'left' ? (!contentLeftIcons.length ? hierarchyOffset : 0) : 0) + _contentOffset
                 };
                 const wrapText = new Text$1(cellTheme.text ? Object.assign({}, cellTheme.text, attribute) : attribute);
@@ -34333,12 +34348,12 @@
         }
         return false;
     }
-    function updateCellContentHeight(cellGroup, distHeight, detaY, autoRowHeight, padding, textAlign, textBaseline) {
+    function updateCellContentHeight(cellGroup, distHeight, detaY, autoRowHeight, padding, textAlign, textBaseline, table) {
         const newHeight = distHeight - Math.floor(padding[0] + padding[2]);
         const textMark = cellGroup.getChildByName('text');
         if (textMark instanceof Text$1 && !autoRowHeight) {
             textMark.setAttributes({
-                heightLimit: newHeight
+                heightLimit: table.options.customConfig?.limitContentHeight === false ? -1 : newHeight
             });
         }
         else if (textMark instanceof RichText && !autoRowHeight) {
@@ -34903,6 +34918,107 @@
         });
     }
 
+    function isSameRange$1(range1, range2) {
+        if (!range1 && !range2) {
+            return true;
+        }
+        if (!range1 || !range2) {
+            return false;
+        }
+        return (range1.start.col === range2.start.col &&
+            range1.start.row === range2.start.row &&
+            range1.end.col === range2.end.col &&
+            range1.end.row === range2.end.row);
+    }
+
+    class InvertHighlightPlugin {
+        table;
+        range;
+        _fill;
+        _opacity;
+        constructor(table, options) {
+            this.table = table;
+            this._fill = options?.fill ?? '#000';
+            this._opacity = options?.opacity ?? 0.5;
+        }
+        setInvertHighlightRange(range) {
+            if (isSameRange$1(this.range, range)) {
+                return;
+            }
+            this.range = range;
+            if (!range) {
+                this.deleteAllCellGroupShadow();
+            }
+            else {
+                this.updateCellGroupShadow();
+            }
+            this.table.scenegraph.updateNextFrame();
+        }
+        deleteAllCellGroupShadow() {
+            if (!this.table.isPivotTable()) {
+                this.updateCellGroupShadowInContainer(this.table.scenegraph.rowHeaderGroup);
+                this.updateCellGroupShadowInContainer(this.table.scenegraph.leftBottomCornerGroup);
+            }
+            this.updateCellGroupShadowInContainer(this.table.scenegraph.bodyGroup);
+            this.updateCellGroupShadowInContainer(this.table.scenegraph.rightFrozenGroup);
+            this.updateCellGroupShadowInContainer(this.table.scenegraph.bottomFrozenGroup);
+            this.updateCellGroupShadowInContainer(this.table.scenegraph.rightBottomCornerGroup);
+        }
+        updateCellGroupShadow() {
+            if (!this.table.isPivotTable()) {
+                this.updateCellGroupShadowInContainer(this.table.scenegraph.rowHeaderGroup, this.range);
+                this.updateCellGroupShadowInContainer(this.table.scenegraph.leftBottomCornerGroup, this.range);
+            }
+            this.updateCellGroupShadowInContainer(this.table.scenegraph.bodyGroup, this.range);
+            this.updateCellGroupShadowInContainer(this.table.scenegraph.rightFrozenGroup, this.range);
+            this.updateCellGroupShadowInContainer(this.table.scenegraph.bottomFrozenGroup), this.range;
+            this.updateCellGroupShadowInContainer(this.table.scenegraph.rightBottomCornerGroup, this.range);
+        }
+        updateCellGroupShadowInContainer(container, range) {
+            container.forEachChildrenSkipChild((column) => {
+                if (column.role === 'column') {
+                    column.forEachChildrenSkipChild((cell) => {
+                        if (cell.role !== 'cell') {
+                            return;
+                        }
+                        cell.attachShadow(cell.shadowRoot);
+                        const shadowGroup = cell.shadowRoot;
+                        if (!range) {
+                            shadowGroup.removeAllChild();
+                        }
+                        else if (cellInRange(range, cell.col, cell.row)) {
+                            shadowGroup.removeAllChild();
+                        }
+                        else if (!shadowGroup.firstChild) {
+                            const shadowRect = createRect({
+                                x: 0,
+                                y: 0,
+                                width: cell.attribute.width,
+                                height: cell.attribute.height,
+                                fill: this._fill,
+                                opacity: this._opacity
+                            });
+                            shadowRect.name = 'shadow-rect';
+                            shadowGroup.appendChild(shadowRect);
+                        }
+                    });
+                }
+            });
+        }
+    }
+    function onBeforeAttributeUpdateForInvertHighlight(val, attribute) {
+        const graphic = this;
+        if (graphic.shadowRoot && graphic.shadowRoot.childrenCount && (isValid$1(val.width) || isValid$1(val.height))) {
+            const shadowRect = graphic.shadowRoot.findChildrenByName('shadow-rect')[0];
+            if (shadowRect) {
+                shadowRect.setAttributes({
+                    width: val.width ?? shadowRect.attribute.width,
+                    height: val.height ?? shadowRect.attribute.height
+                });
+            }
+        }
+    }
+
     function createCell(type, value, define, table, col, row, colWidth, cellWidth, cellHeight, columnGroup, y, padding, textAlign, textBaseline, mayHaveIcon, cellTheme, range, customResult) {
         let isAsync = false;
         let cellGroup;
@@ -35021,6 +35137,7 @@
             const createRadioCellGroup = Factory.getFunction('createRadioCellGroup');
             cellGroup = createRadioCellGroup(null, columnGroup, 0, y, col, row, colWidth, cellWidth, cellHeight, padding, textAlign, textBaseline, table, cellTheme, define);
         }
+        cellGroup.onBeforeAttributeUpdate = onBeforeAttributeUpdateForInvertHighlight;
         return cellGroup;
     }
     function updateCell$1(col, row, table, addNew, isShadow) {
@@ -35276,7 +35393,7 @@
                     continue;
                 }
                 if (range.start.row !== range.end.row && cellGroup.contentHeight !== cellHeight) {
-                    updateCellContentHeight(cellGroup, cellHeight, cellHeight, table.isAutoRowHeight(row), padding, textAlign, textBaseline);
+                    updateCellContentHeight(cellGroup, cellHeight, cellHeight, table.isAutoRowHeight(row), padding, textAlign, textBaseline, table);
                 }
                 if (range.start.col !== range.end.col && cellGroup.contentWidth !== cellWidth) {
                     updateCellContentWidth(cellGroup, cellWidth, cellHeight, 0, table.isAutoRowHeight(row), padding, textAlign, textBaseline, table.scenegraph);
@@ -35292,7 +35409,7 @@
     function dealWithMergeCellSizeForShadow(range, cellWidth, cellHeight, padding, textAlign, textBaseline, table, cellGroup) {
         const { col, row } = cellGroup;
         if (range.start.row !== range.end.row && cellGroup.contentHeight !== cellHeight) {
-            updateCellContentHeight(cellGroup, cellHeight, cellHeight, table.isAutoRowHeight(row), padding, textAlign, textBaseline);
+            updateCellContentHeight(cellGroup, cellHeight, cellHeight, table.isAutoRowHeight(row), padding, textAlign, textBaseline, table);
         }
         if (range.start.col !== range.end.col && cellGroup.contentWidth !== cellWidth) {
             updateCellContentWidth(cellGroup, cellWidth, cellHeight, 0, table.isAutoRowHeight(row), padding, textAlign, textBaseline, table.scenegraph);
@@ -35697,7 +35814,8 @@
         table.defaultHeaderColWidth;
         const isDefaultHeaderHasAuto = table.defaultHeaderRowHeight === 'auto' ||
             (isArray$1(table.defaultHeaderRowHeight) && table.defaultHeaderRowHeight.some(item => item === 'auto'));
-        const isAllRowsAuto = table.heightMode === 'autoHeight' || table.heightMode === 'adaptive';
+        const isAllRowsAuto = table.heightMode === 'autoHeight' ||
+            (table.heightMode === 'adaptive' && table.options.autoHeightInAdaptiveMode !== false);
         if (isAllRowsAuto || isDefaultHeaderHasAuto) {
             rowStart = rowStart ?? 0;
             rowEnd = rowEnd ?? table.rowCount - 1;
@@ -35717,7 +35835,9 @@
                 if (isAllRowsAuto || table.getDefaultRowHeight(row) === 'auto') {
                     const height = computeRowHeight(row, startCol, endCol, table);
                     newHeights[row] = Math.round(height);
-                    table._setRowHeight(row, height);
+                    if (table.heightAdaptiveMode === 'only-body' || !update) {
+                        table._setRowHeight(row, height);
+                    }
                 }
             }
             for (let row = table.rowCount - table.bottomFrozenRowCount; row <= rowEnd; row++) {
@@ -35882,7 +36002,7 @@
         if (update) {
             for (let row = rowStart; row <= rowEnd; row++) {
                 const newRowHeight = newHeights[row] ?? table.getRowHeight(row);
-                if (newRowHeight !== (oldRowHeights[row] ?? table.getRowHeight(row))) {
+                if (isValid$1(newRowHeight)) {
                     table._setRowHeight(row, newRowHeight);
                 }
             }
@@ -36491,7 +36611,7 @@
                     });
                     if (renderDefault) {
                         const style = table._getCellStyle(colStart, rowStart);
-                        updateCellContentHeight(singleCellGroup, distHeight, detaY, autoRowHeight, getQuadProps(style.padding), style.textAlign, style.textBaseline);
+                        updateCellContentHeight(singleCellGroup, distHeight, detaY, autoRowHeight, getQuadProps(style.padding), style.textAlign, style.textBaseline, table);
                     }
                     const rangeHeight = table.getRowHeight(row);
                     const rangeWidth = table.getColWidth(col);
@@ -36514,7 +36634,7 @@
         }
         else {
             const style = table._getCellStyle(cellGroup.col, cellGroup.row);
-            updateCellContentHeight(cellGroup, distHeight, detaY, autoRowHeight, getQuadProps(style.padding), style.textAlign, style.textBaseline);
+            updateCellContentHeight(cellGroup, distHeight, detaY, autoRowHeight, getQuadProps(style.padding), style.textAlign, style.textBaseline, table);
         }
     }
 
@@ -51756,7 +51876,11 @@
                 }
                 else if (!this.table.isHeader(eventArgs.col, eventArgs.row) && define?.disableSelect) {
                     if (!isSelectMoving) {
+                        const isHasSelected = !!this.table.stateManager.select.ranges?.length;
                         this.table.stateManager.updateSelectPos(-1, -1);
+                        if (isHasSelected) {
+                            this.table.stateManager.endSelectCells(true, isHasSelected);
+                        }
                     }
                     return false;
                 }
@@ -54002,19 +54126,24 @@
         }
         getCustomCellStyleId(col, row) {
             let customStyleId;
-            this.customCellStyleArrangement.forEach(style => {
-                if (style.cellPosition.range) {
-                    if (style.cellPosition.range.start.col <= col &&
-                        style.cellPosition.range.end.col >= col &&
-                        style.cellPosition.range.start.row <= row &&
-                        style.cellPosition.range.end.row >= row) {
-                        customStyleId = style.customStyleId;
-                    }
-                }
-                else if (style.cellPosition.col === col && style.cellPosition.row === row) {
-                    customStyleId = style.customStyleId;
+            const range = this.table.getCellRange(col, row);
+            for (let c = range.start.col; c <= range.end.col; c++) {
+                for (let r = range.start.row; r <= range.end.row; r++) {
+                    this.customCellStyleArrangement.forEach(style => {
+                        if (style.cellPosition.range) {
+                            if (style.cellPosition.range.start.col <= c &&
+                                style.cellPosition.range.end.col >= c &&
+                                style.cellPosition.range.start.row <= r &&
+                                style.cellPosition.range.end.row >= r) {
+                                customStyleId = style.customStyleId;
+                            }
+                        }
+                        else if (style.cellPosition.col === c && style.cellPosition.row === r) {
+                            customStyleId = style.customStyleId;
+                        }
+                    });
                 }
-            });
+            }
             return customStyleId;
         }
         getCustomCellStyleOption(customStyleId) {
@@ -54061,7 +54190,10 @@
                 }
                 return style.cellPosition.col === cellPos.col && style.cellPosition.row === cellPos.row;
             });
-            if (index === -1) {
+            if (index === -1 && !customStyleId) {
+                return;
+            }
+            else if (index === -1 && customStyleId) {
                 this.customCellStyleArrangement.push({
                     cellPosition: {
                         col: cellPos.col,
@@ -54074,13 +54206,21 @@
             else if (this.customCellStyleArrangement[index].customStyleId === customStyleId) {
                 return;
             }
-            else {
+            else if (customStyleId) {
                 this.customCellStyleArrangement[index].customStyleId = customStyleId;
             }
+            else {
+                this.customCellStyleArrangement.splice(index, 1);
+            }
             if (cellPos.range) {
                 for (let col = cellPos.range.start.col; col <= cellPos.range.end.col; col++) {
                     for (let row = cellPos.range.start.row; row <= cellPos.range.end.row; row++) {
-                        this.table.scenegraph.updateCellContent(col, row);
+                        const range = this.table.getCellRange(col, row);
+                        for (let c = range.start.col; c <= range.end.col; c++) {
+                            for (let r = range.start.row; r <= range.end.row; r++) {
+                                this.table.scenegraph.updateCellContent(c, r);
+                            }
+                        }
                     }
                 }
             }
@@ -56114,7 +56254,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.10.3";
+        version = "1.10.4-alpha.2";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -75435,8 +75575,241 @@
         return new Radio(params ? params.attribute : {});
     }
 
+    class CarouselAnimationPlugin {
+        table;
+        rowCount;
+        colCount;
+        animationDuration;
+        animationDelay;
+        animationEasing;
+        replaceScrollAction;
+        playing;
+        row;
+        col;
+        constructor(table, options) {
+            this.table = table;
+            this.rowCount = options?.rowCount ?? undefined;
+            this.colCount = options?.colCount ?? undefined;
+            this.animationDuration = options?.animationDuration ?? 500;
+            this.animationDelay = options?.animationDelay ?? 1000;
+            this.animationEasing = options?.animationEasing ?? 'linear';
+            this.replaceScrollAction = options?.replaceScrollAction ?? false;
+            this.playing = false;
+            this.row = table.frozenRowCount;
+            this.col = table.frozenColCount;
+            this.init();
+        }
+        init() {
+            if (this.replaceScrollAction) {
+                this.table.disableScroll();
+                this.table.scenegraph.stage.addEventListener('wheel', this.onScrollEnd.bind(this));
+            }
+        }
+        onScrollEnd(e) {
+            if (this.rowCount) {
+                if (e.deltaY > 0) {
+                    this.row += this.rowCount;
+                    this.row = Math.min(this.row, this.table.rowCount - this.table.frozenRowCount);
+                }
+                else if (e.deltaY < 0) {
+                    this.row -= this.rowCount;
+                    this.row = Math.max(this.row, this.table.frozenRowCount);
+                }
+                this.table.scrollToRow(this.row, { duration: this.animationDuration, easing: this.animationEasing });
+            }
+            else if (this.colCount) {
+                if (e.deltaX > 0) {
+                    this.col += this.colCount;
+                    this.col = Math.min(this.col, this.table.colCount - this.table.frozenColCount);
+                }
+                else if (e.deltaX < 0) {
+                    this.col -= this.colCount;
+                    this.col = Math.max(this.col, this.table.frozenColCount);
+                }
+                this.table.scrollToCol(this.col, { duration: this.animationDuration, easing: this.animationEasing });
+            }
+        }
+        play() {
+            this.playing = true;
+            if (this.rowCount) {
+                this.updateRow();
+            }
+            else if (this.colCount) {
+                this.updateCol();
+            }
+        }
+        pause() {
+            this.playing = false;
+        }
+        updateRow() {
+            if (!this.playing) {
+                return;
+            }
+            let animation = true;
+            if (this.table.scenegraph.proxy.screenTopRow !== this.row) {
+                this.row = this.table.frozenRowCount;
+                animation = false;
+            }
+            else {
+                this.row += this.rowCount;
+            }
+            this.table.scrollToRow(this.row, animation ? { duration: this.animationDuration, easing: this.animationEasing } : undefined);
+            setTimeout(() => {
+                this.updateRow();
+            }, animation ? this.animationDuration + this.animationDelay : 0);
+        }
+        updateCol() {
+            if (!this.playing) {
+                return;
+            }
+            let animation = true;
+            if (this.table.scenegraph.proxy.screenLeftCol !== this.col) {
+                this.col = this.table.frozenColCount;
+                animation = false;
+            }
+            else {
+                this.col += this.colCount;
+            }
+            this.table.scrollToCol(this.col, animation ? { duration: this.animationDuration, easing: this.animationEasing } : undefined);
+            setTimeout(() => {
+                this.updateCol();
+            }, animation ? this.animationDuration + this.animationDelay : 0);
+        }
+    }
+
+    class HeaderHighlightPlugin {
+        table;
+        options;
+        colHeaderRange;
+        rowHeaderRange;
+        constructor(table, options) {
+            this.table = table;
+            this.options = options;
+            this.registerStyle();
+            this.bindEvent();
+        }
+        registerStyle() {
+            this.table.registerCustomCellStyle('col-highlight', {
+                bgColor: this.options?.colHighlightBGColor ?? '#82b2f5',
+                color: this.options?.colHighlightColor ?? '#FFF'
+            });
+            this.table.registerCustomCellStyle('row-highlight', {
+                bgColor: this.options?.rowHighlightBGColor ?? '#82b2f5',
+                color: this.options?.rowHighlightColor ?? '#FFF'
+            });
+        }
+        bindEvent() {
+            this.table.on('selected_cell', e => {
+                this.updateHighlight();
+            });
+            this.table.on('selected_clear', () => {
+                this.clearHighlight();
+            });
+        }
+        clearHighlight() {
+            this.colHeaderRange && this.table.arrangeCustomCellStyle({ range: this.colHeaderRange }, undefined);
+            this.rowHeaderRange && this.table.arrangeCustomCellStyle({ range: this.rowHeaderRange }, undefined);
+            this.colHeaderRange = undefined;
+            this.rowHeaderRange = undefined;
+        }
+        updateHighlight() {
+            if (this.options?.colHighlight === false && this.options?.rowHighlight === false) {
+                return;
+            }
+            const selectRanges = this.table.getSelectedCellRanges();
+            if (selectRanges.length === 0) {
+                this.clearHighlight();
+                return;
+            }
+            const selectRange = selectRanges[0];
+            const rowSelectRange = [selectRange.start.row, selectRange.end.row];
+            rowSelectRange.sort((a, b) => a - b);
+            const colSelectRange = [selectRange.start.col, selectRange.end.col];
+            colSelectRange.sort((a, b) => a - b);
+            let colHeaderRange;
+            let rowHeaderRange;
+            if (this.table.isPivotTable()) {
+                colHeaderRange = {
+                    start: {
+                        col: colSelectRange[0],
+                        row: 0
+                    },
+                    end: {
+                        col: colSelectRange[1],
+                        row: this.table.columnHeaderLevelCount - 1
+                    }
+                };
+                rowHeaderRange = {
+                    start: {
+                        col: 0,
+                        row: rowSelectRange[0]
+                    },
+                    end: {
+                        col: this.table.rowHeaderLevelCount - 1,
+                        row: rowSelectRange[1]
+                    }
+                };
+            }
+            else if (this.table.internalProps.transpose) {
+                rowHeaderRange = {
+                    start: {
+                        col: 0,
+                        row: rowSelectRange[0]
+                    },
+                    end: {
+                        col: this.table.rowHeaderLevelCount - 1,
+                        row: rowSelectRange[1]
+                    }
+                };
+            }
+            else {
+                colHeaderRange = {
+                    start: {
+                        col: colSelectRange[0],
+                        row: 0
+                    },
+                    end: {
+                        col: colSelectRange[1],
+                        row: this.table.columnHeaderLevelCount - 1
+                    }
+                };
+                if (this.table.internalProps.rowSeriesNumber) {
+                    rowHeaderRange = {
+                        start: {
+                            col: 0,
+                            row: rowSelectRange[0]
+                        },
+                        end: {
+                            col: 0,
+                            row: rowSelectRange[1]
+                        }
+                    };
+                }
+            }
+            if (this.options?.colHighlight !== false && !isSameRange(this.colHeaderRange, colHeaderRange)) {
+                this.colHeaderRange && this.table.arrangeCustomCellStyle({ range: this.colHeaderRange }, undefined);
+                colHeaderRange && this.table.arrangeCustomCellStyle({ range: colHeaderRange }, 'col-highlight');
+                this.colHeaderRange = colHeaderRange;
+            }
+            if (this.options?.rowHighlight !== false && !isSameRange(this.rowHeaderRange, rowHeaderRange)) {
+                this.rowHeaderRange && this.table.arrangeCustomCellStyle({ range: this.rowHeaderRange }, undefined);
+                rowHeaderRange && this.table.arrangeCustomCellStyle({ range: rowHeaderRange }, 'row-highlight');
+                this.rowHeaderRange = rowHeaderRange;
+            }
+        }
+    }
+    function isSameRange(a, b) {
+        if (a === undefined && b === undefined) {
+            return true;
+        }
+        if (a === undefined || b === undefined) {
+            return false;
+        }
+        return (a.start.col === b.start.col && a.start.row === b.start.row && a.end.col === b.end.col && a.end.row === b.end.row);
+    }
+
     registerForVrender();
-    const version = "1.10.3";
+    const version = "1.10.4-alpha.2";
     function getIcons() {
         return get$2();
     }
@@ -75444,8 +75817,11 @@
         clearAll();
     }
 
+    exports.CarouselAnimationPlugin = CarouselAnimationPlugin;
     exports.CustomLayout = index;
     exports.DataStatistics = DataStatistics;
+    exports.HeaderHighlightPlugin = HeaderHighlightPlugin;
+    exports.InvertHighlightPlugin = InvertHighlightPlugin;
     exports.ListTable = ListTableAll;
     exports.ListTableSimple = ListTableSimple;
     exports.PIVOT_CHART_EVENT_TYPE = PIVOT_CHART_EVENT_TYPE;
@@ -75478,6 +75854,7 @@
     exports.getTargetCell = getTargetCell;
     exports.graphicUtil = graphicUtil;
     exports.jsx = jsx;
+    exports.onBeforeAttributeUpdateForInvertHighlight = onBeforeAttributeUpdateForInvertHighlight;
     exports.register = register$1;
     exports.registerAxis = registerAxis;
     exports.registerChartCell = registerChartCell;