k-vtable 1.0.0

package/es/state/state.js

@@ -0,0 +1,834 @@
+import { MenuType } from "../scenegraph/component/menu";
+
+import { HighlightScope, InteractionState } from "../ts-types";
+
+import { IconFuncTypeEnum } from "../ts-types";
+
+import { checkMultiCellInSelect } from "./common/check-in-select";
+
+import { updateHoverPosition } from "./hover/update-position";
+
+import { dealFreeze } from "./frozen";
+
+import { dealSort } from "./sort";
+
+import { selectEnd, updateSelectPosition } from "./select/update-position";
+
+import { cellInRange } from "../tools/helper";
+
+import { PIVOT_TABLE_EVENT_TYPE } from "../ts-types/pivot-table/PIVOT_TABLE_EVENT_TYPE";
+
+import { TABLE_EVENT_TYPE } from "../core/TABLE_EVENT_TYPE";
+
+import { Bounds, isObject, isString, isValid } from "@visactor/vutils";
+
+import { updateDrill } from "./drill";
+
+import { clearChartHover, updateChartHover } from "./spark-line";
+
+import { endMoveCol, startMoveCol, updateMoveCol } from "./cell-move";
+
+import { getIconAndPositionFromTarget } from "../scenegraph/utils/icon";
+
+import { debounce } from "../tools/debounce";
+
+import { updateResizeColumn } from "./resize/update-resize-column";
+
+import { changeRadioOrder, setRadioState, syncRadioState } from "./radio/radio";
+
+import { changeCheckboxOrder, initCheckedState, initLeftRecordsCheckState, setCheckedState, setHeaderCheckedState, syncCheckedState, updateHeaderCheckedState } from "./checkbox/checkbox";
+
+import { updateResizeRow } from "./resize/update-resize-row";
+
+import { deleteAllSelectingBorder } from "../scenegraph/select/delete-select-border";
+
+import { traverseObject } from "../tools/util";
+
+import { addCustomSelectRanges, deletaCustomSelectRanges } from "./select/custom-select";
+
+import { expendCellRange } from "../tools/merge-range";
+
+export class StateManager {
+    constructor(table) {
+        this.fastScrolling = !1, this.checkedState = new Map, this.headerCheckedState = {}, 
+        this._checkboxCellTypeFields = [], this._headerCheckFuncs = {}, this.radioState = {}, 
+        this.resetInteractionState = debounce((state => {
+            this.updateInteractionState(null != state ? state : InteractionState.default);
+        }), 100), this.table = table, this.initState(), this.updateVerticalScrollBar = this.updateVerticalScrollBar.bind(this), 
+        this.updateHorizontalScrollBar = this.updateHorizontalScrollBar.bind(this);
+    }
+    initState() {
+        this._initState(), this.setHoverState(), this.setSelectState(), this.setFrozenState();
+    }
+    updateOptionSetState() {
+        this._updateOptionSetState(), this.setHoverState(), this.setSelectState(), this.setFrozenState();
+    }
+    _updateOptionSetState() {
+        this.interactionState = InteractionState.default, this.hoverIcon = {
+            col: -1,
+            row: -1,
+            icon: null
+        }, this.columnResize = {
+            col: -1,
+            x: 0,
+            resizing: !1
+        }, this.rowResize = {
+            row: -1,
+            y: 0,
+            resizing: !1
+        }, this.columnMove = {
+            colSource: -1,
+            colTarget: -1,
+            rowSource: -1,
+            rowTarget: -1,
+            x: 0,
+            y: 0,
+            moving: !1
+        }, this.menu = {
+            x: -1,
+            y: -1,
+            isShow: !1,
+            itemList: [],
+            bounds: new Bounds,
+            highlightIndex: -1,
+            dropDownMenuHighlight: []
+        }, this.sort = [ {
+            col: -1,
+            row: -1,
+            order: "normal"
+        } ], this.frozen = {
+            col: -1,
+            row: -1
+        }, this.tablePosition = {
+            absoluteX: 0,
+            absoluteY: 0
+        }, this.drill = {
+            col: -1,
+            row: -1
+        }, this.sparkLine = {
+            col: -1,
+            row: -1
+        };
+    }
+    _initState() {
+        this.interactionState = InteractionState.default, this.select = {
+            highlightScope: HighlightScope.single,
+            ranges: [],
+            cellPos: {
+                col: -1,
+                row: -1
+            },
+            selecting: !1
+        }, this.fillHandle = {
+            isFilling: !1,
+            startX: void 0,
+            startY: void 0
+        }, this.hover = {
+            highlightScope: HighlightScope.single,
+            cellPos: {
+                col: -1,
+                row: -1
+            }
+        }, this.hoverIcon = {
+            col: -1,
+            row: -1,
+            icon: null
+        }, this.columnResize = {
+            col: -1,
+            x: 0,
+            resizing: !1
+        }, this.rowResize = {
+            row: -1,
+            y: 0,
+            resizing: !1
+        }, this.columnMove = {
+            colSource: -1,
+            colTarget: -1,
+            rowSource: -1,
+            rowTarget: -1,
+            x: 0,
+            y: 0,
+            moving: !1
+        }, this.menu = {
+            x: -1,
+            y: -1,
+            isShow: !1,
+            itemList: [],
+            bounds: new Bounds,
+            highlightIndex: -1,
+            dropDownMenuHighlight: []
+        }, this.sort = [ {
+            col: -1,
+            row: -1,
+            order: "normal"
+        } ], this.frozen = {
+            col: -1,
+            row: -1
+        }, this.scroll = {
+            horizontalBarPos: 0,
+            verticalBarPos: 0
+        }, this.tablePosition = {
+            absoluteX: 0,
+            absoluteY: 0
+        }, this.drill = {
+            col: -1,
+            row: -1
+        }, this.sparkLine = {
+            col: -1,
+            row: -1
+        };
+    }
+    setHoverState() {
+        var _a;
+        const {highlightMode: highlightMode, disableHover: disableHover, disableHeaderHover: disableHeaderHover} = null !== (_a = this.table.options.hover) && void 0 !== _a ? _a : {
+            highlightMode: "cell"
+        };
+        disableHover ? this.hover.highlightScope = HighlightScope.none : "cross" === highlightMode ? this.hover.highlightScope = HighlightScope.cross : "row" === highlightMode ? this.hover.highlightScope = HighlightScope.row : "column" === highlightMode ? this.hover.highlightScope = HighlightScope.column : "cell" === highlightMode && (this.hover.highlightScope = HighlightScope.single), 
+        this.hover.singleStyle = !disableHover, this.hover.disableHeader = disableHeaderHover, 
+        (this.hover.highlightScope === HighlightScope.none || disableHeaderHover) && (this.hover.cellPosContainHeader = {
+            col: -1,
+            row: -1
+        });
+    }
+    setSelectState() {
+        var _a;
+        const {headerSelectMode: headerSelectMode, disableSelect: disableSelect, disableHeaderSelect: disableHeaderSelect, highlightMode: highlightMode, highlightInRange: highlightInRange} = Object.assign({}, {
+            headerSelectMode: "inline",
+            disableSelect: !1,
+            disableHeaderSelect: !1,
+            highlightMode: "cell",
+            highlightInRange: !1
+        }, this.table.options.select);
+        this.select.highlightScope = !0 === disableSelect ? HighlightScope.none : "cross" === highlightMode ? HighlightScope.cross : "row" === highlightMode ? HighlightScope.row : "column" === highlightMode ? HighlightScope.column : HighlightScope.single, 
+        this.select.singleStyle = !disableSelect, this.select.disableHeader = disableHeaderSelect, 
+        this.select.headerSelectMode = headerSelectMode, this.select.highlightInRange = highlightInRange, 
+        this.select.disableCtrlMultiSelect = !1 === (null === (_a = this.table.options.keyboardOptions) || void 0 === _a ? void 0 : _a.ctrlMultiSelect);
+    }
+    isSelected(col, row) {
+        let seled = !1;
+        return this.select.ranges.forEach((range => {
+            cellInRange(range, col, row) && (seled = !0);
+        })), seled;
+    }
+    setSortState(sortState) {
+        const state = this;
+        const sort = (sortState = !sortState || Array.isArray(sortState) ? sortState : [ sortState ]) && sortState.reduce(((prev, item) => {
+            var _a, _b, _c;
+            const column = null === (_a = function(columns) {
+                const result = [];
+                return function flatten(cols, parentStartIndex = 0) {
+                    cols.forEach((col => {
+                        var _a;
+                        const startIndex = col.startInTotal ? null !== (_a = col.startInTotal + state.table.internalProps.layoutMap.leftRowSeriesNumberColumnCount) && void 0 !== _a ? _a : 0 : parentStartIndex;
+                        col.columns ? flatten(col.columns, startIndex) : result.push(Object.assign(Object.assign({}, col), {
+                            startIndex: startIndex
+                        }));
+                    }));
+                }(columns), result;
+            }(this.table.internalProps.columns)) || void 0 === _a ? void 0 : _a.find((column => (null == column ? void 0 : column.field) === (null == item ? void 0 : item.field)));
+            return this.table.internalProps.transpose ? prev.push({
+                field: item.field,
+                order: item.order,
+                row: null !== (_b = (null == column ? void 0 : column.startInTotal) + this.table.internalProps.layoutMap.leftRowSeriesNumberColumnCount) && void 0 !== _b ? _b : 0,
+                col: null == column ? void 0 : column.level
+            }) : prev.push({
+                field: item.field,
+                order: item.order,
+                col: null !== (_c = (null == column ? void 0 : column.startInTotal) + this.table.internalProps.layoutMap.leftRowSeriesNumberColumnCount) && void 0 !== _c ? _c : 0,
+                row: null == column ? void 0 : column.level
+            }), prev;
+        }), []);
+        this.sort = sort || [];
+    }
+    setFrozenState() {
+        this.frozen.col = this.table.frozenColCount - 1;
+    }
+    updateInteractionState(mode) {
+        if (this.interactionState === mode) return;
+        mode === InteractionState.scrolling && (this.interactionStateBeforeScroll = this.interactionState);
+        const oldState = this.interactionState;
+        this.interactionState = mode, oldState === InteractionState.scrolling && InteractionState.default;
+    }
+    updateHoverhighlightScope(mode) {
+        this.hover.highlightScope !== mode && (this.hover.highlightScope = mode);
+    }
+    updateHoverPos(col, row) {
+        updateHoverPosition(this, col, row);
+    }
+    updateSelectPos(col, row, isShift = !1, isCtrl = !1, isSelectAll = !1, makeSelectCellVisible = !0, skipBodyMerge = !1) {
+        -1 !== row && -1 !== row && (this.select.selecting = !0), col < 0 && (col = -1), 
+        row < 0 && (row = -1), col > this.table.colCount - 1 && (col = this.table.colCount - 1), 
+        row > this.table.rowCount - 1 && (row = this.table.rowCount - 1), updateSelectPosition(this, col, row, isShift, isCtrl, isSelectAll, makeSelectCellVisible, skipBodyMerge);
+    }
+    checkCellRangeInSelect(cellPosStart, cellPosEnd) {
+        return checkMultiCellInSelect(cellPosStart, cellPosEnd, this.select.ranges, this.select.highlightScope);
+    }
+    updateHoverIcon(col, row, target, cellGroup) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        if ((null === (_a = this.residentHoverIcon) || void 0 === _a ? void 0 : _a.icon) && target === (null === (_b = this.residentHoverIcon) || void 0 === _b ? void 0 : _b.icon)) return;
+        const iconInfo = getIconAndPositionFromTarget(target);
+        if (iconInfo) if ("richtext-icon" === iconInfo.type) {
+            const inlineIcon = iconInfo.icon;
+            if (this.hoverIcon.icon && this.hoverIcon.icon !== (null === (_d = this.residentHoverIcon) || void 0 === _d ? void 0 : _d.icon) && (this.table.scenegraph.setIconNormalStyle(this.hoverIcon.icon, this.hoverIcon.col, this.hoverIcon.row), 
+            this.hoverIcon.col = -1, this.hoverIcon.col = -1, this.hoverIcon.icon = null, this.table.scenegraph.updateNextFrame()), 
+            inlineIcon.attribute.tooltip) {
+                const tooltipOptions = {
+                    content: inlineIcon.attribute.tooltip.title,
+                    referencePosition: {
+                        rect: iconInfo.position,
+                        placement: inlineIcon.attribute.tooltip.placement
+                    },
+                    style: Object.assign({}, null === (_e = this.table.internalProps.theme) || void 0 === _e ? void 0 : _e.tooltipStyle, null === (_f = inlineIcon.tooltip) || void 0 === _f ? void 0 : _f.style, null === (_h = null === (_g = inlineIcon.attribute) || void 0 === _g ? void 0 : _g.tooltip) || void 0 === _h ? void 0 : _h.style),
+                    disappearDelay: inlineIcon.attribute.tooltip.disappearDelay
+                };
+                this.table.internalProps.tooltipHandler.isBinded(tooltipOptions) || this.table.showTooltip(col, row, tooltipOptions);
+            }
+        } else {
+            const icon = iconInfo.icon;
+            icon !== this.hoverIcon.icon && (this.hoverIcon.icon && this.hoverIcon.icon !== (null === (_j = this.residentHoverIcon) || void 0 === _j ? void 0 : _j.icon) && this.table.scenegraph.setIconNormalStyle(this.hoverIcon.icon, this.hoverIcon.col, this.hoverIcon.row), 
+            this.hoverIcon.col = col, this.hoverIcon.row = row, this.hoverIcon.icon = icon, 
+            this.table.scenegraph.setIconHoverStyle(icon, col, row, cellGroup), this.table.scenegraph.updateNextFrame());
+        } else this.hoverIcon.icon && this.hoverIcon.icon !== (null === (_c = this.residentHoverIcon) || void 0 === _c ? void 0 : _c.icon) && (this.table.scenegraph.setIconNormalStyle(this.hoverIcon.icon, this.hoverIcon.col, this.hoverIcon.row), 
+        this.hoverIcon.col = -1, this.hoverIcon.col = -1, this.hoverIcon.icon = null, this.table.scenegraph.updateNextFrame());
+    }
+    isResizeCol() {
+        return this.columnResize.resizing;
+    }
+    isResizeRow() {
+        return this.rowResize.resizing;
+    }
+    isFillHandle() {
+        return this.fillHandle.isFilling;
+    }
+    isSelecting() {
+        return this.select.selecting;
+    }
+    endSelectCells(fireListener = !0, fireClear = !0) {
+        if (this.select.selecting) {
+            if (this.select.selecting = !1, 0 === this.select.ranges.length) return;
+            const currentRange = this.select.ranges[this.select.ranges.length - 1];
+            this.table.isSeriesNumber(this.select.cellPos.col, this.select.cellPos.row) || this.table.isHeader(this.select.cellPos.col, this.select.cellPos.row) || expendCellRange(currentRange, this.table);
+            let isSame = !1;
+            for (let i = 0; i < this.select.ranges.length - 1; i++) {
+                const range = this.select.ranges[i];
+                if (range && range.start.col === currentRange.start.col && range.start.row === currentRange.start.row && range.end.col === currentRange.end.col && range.end.row === currentRange.end.row) {
+                    isSame = !0;
+                    break;
+                }
+            }
+            isSame ? (this.select.ranges.pop(), deleteAllSelectingBorder(this.table.scenegraph), 
+            this.table.scenegraph.selectingRangeComponents.clear()) : selectEnd(this.table.scenegraph);
+            const lastCol = this.select.ranges[this.select.ranges.length - 1].end.col, lastRow = this.select.ranges[this.select.ranges.length - 1].end.row;
+            fireListener && this.table.fireListeners(TABLE_EVENT_TYPE.SELECTED_CELL, {
+                ranges: this.select.ranges,
+                col: lastCol,
+                row: lastRow
+            });
+        } else fireClear && 0 === this.select.ranges.length && this.table.fireListeners(TABLE_EVENT_TYPE.SELECTED_CLEAR, {});
+    }
+    endResizeCol() {
+        setTimeout((() => {
+            this.columnResize.resizing = !1;
+        }), 0), this.table.scenegraph.updateChartSizeForResizeColWidth(this.columnResize.col), 
+        this.checkFrozen(), this.table.scenegraph.component.hideResizeCol(), this.table.scenegraph.updateNextFrame();
+    }
+    startResizeCol(col, x, y, isRightFrozen) {
+        this.columnResize.resizing = !0, this.columnResize.col = col, this.columnResize.x = x, 
+        this.columnResize.isRightFrozen = isRightFrozen, this.table.scenegraph.component.showResizeCol(col, y, isRightFrozen), 
+        this.table.scenegraph.updateNextFrame();
+    }
+    updateResizeCol(xInTable, yInTable) {
+        updateResizeColumn(xInTable, yInTable, this);
+    }
+    endResizeRow() {
+        setTimeout((() => {
+            this.rowResize.resizing = !1;
+        }), 0), this.table.scenegraph.updateChartSizeForResizeRowHeight(this.rowResize.row), 
+        this.table.scenegraph.component.hideResizeRow(), this.table.scenegraph.updateNextFrame();
+    }
+    startResizeRow(row, x, y, isBottomFrozen) {
+        this.rowResize.resizing = !0, this.rowResize.row = row, this.rowResize.y = y, this.rowResize.isBottomFrozen = isBottomFrozen, 
+        this.table.scenegraph.component.showResizeRow(row, x, isBottomFrozen), this.table.scenegraph.updateNextFrame();
+    }
+    updateResizeRow(xInTable, yInTable) {
+        updateResizeRow(xInTable, yInTable, this);
+    }
+    startFillSelect(x, y) {
+        this.fillHandle.isFilling = !0, this.fillHandle.startX = x, this.fillHandle.startY = y;
+        const currentRange = this.select.ranges[this.select.ranges.length - 1];
+        this.fillHandle.beforeFillMinCol = Math.min(currentRange.start.col, currentRange.end.col), 
+        this.fillHandle.beforeFillMinRow = Math.min(currentRange.start.row, currentRange.end.row), 
+        this.fillHandle.beforeFillMaxCol = Math.max(currentRange.start.col, currentRange.end.col), 
+        this.fillHandle.beforeFillMaxRow = Math.max(currentRange.start.row, currentRange.end.row), 
+        this.table.fireListeners(TABLE_EVENT_TYPE.MOUSEDOWN_FILL_HANDLE, {});
+    }
+    endFillSelect() {
+        this.fillHandle.isFilling = !1, this.fillHandle.startX = void 0, this.fillHandle.startY = void 0, 
+        this.fillHandle.directionRow = void 0;
+        const currentMinCol = Math.min(this.select.ranges[0].start.col, this.select.ranges[0].end.col), currentMinRow = Math.min(this.select.ranges[0].start.row, this.select.ranges[0].end.row), currentMaxCol = Math.max(this.select.ranges[0].start.col, this.select.ranges[0].end.col), currentMaxRow = Math.max(this.select.ranges[0].start.row, this.select.ranges[0].end.row);
+        this.fillHandle.beforeFillMinCol === currentMinCol && this.fillHandle.beforeFillMinRow === currentMinRow && this.fillHandle.beforeFillMaxCol === currentMaxCol && this.fillHandle.beforeFillMaxRow === currentMaxRow || this.table.eventManager.isDraging && this.table.fireListeners(TABLE_EVENT_TYPE.DRAG_FILL_HANDLE_END, {
+            direction: this.fillHandle.direction
+        }), this.fillHandle.beforeFillMaxCol = void 0, this.fillHandle.beforeFillMaxRow = void 0, 
+        this.fillHandle.beforeFillMinCol = void 0, this.fillHandle.beforeFillMinRow = void 0;
+    }
+    startMoveCol(col, row, x, y, event) {
+        startMoveCol(col, row, x, y, this, event);
+    }
+    updateMoveCol(col, row, x, y, event) {
+        updateMoveCol(col, row, x, y, this, event);
+    }
+    isMoveCol() {
+        return this.columnMove.moving;
+    }
+    endMoveCol() {
+        return endMoveCol(this);
+    }
+    checkFrozen() {
+        var _a;
+        let originalFrozenColCount = this.table.options.frozenColCount ? this.table.options.frozenColCount : this.table.isPivotTable() || this.table.isListTable() && this.table.internalProps.transpose ? (null !== (_a = this.table.rowHeaderLevelCount) && void 0 !== _a ? _a : 0) + this.table.internalProps.layoutMap.leftRowSeriesNumberColumnCount : 0;
+        if (originalFrozenColCount) {
+            originalFrozenColCount > this.table.colCount && (originalFrozenColCount = this.table.colCount);
+            const maxFrozenWidth = this.table._getMaxFrozenWidth();
+            if (this.table.getColsWidth(0, originalFrozenColCount - 1) > maxFrozenWidth) if (this.table.internalProps.unfreezeAllOnExceedsMaxWidth) this.table._setFrozenColCount(0), 
+            this.setFrozenCol(-1); else {
+                const computedFrozenColCount = this.table._getComputedFrozenColCount(originalFrozenColCount);
+                this.table._setFrozenColCount(computedFrozenColCount), this.setFrozenCol(computedFrozenColCount);
+            } else this.table.frozenColCount !== originalFrozenColCount && (this.table._setFrozenColCount(originalFrozenColCount), 
+            this.setFrozenCol(originalFrozenColCount));
+        }
+    }
+    setFrozenCol(col) {
+        col !== this.frozen.col ? (this.frozen.col = col, this.table.scenegraph.updateFrozen(), 
+        this.table.scenegraph.updateFrozenIcon(0, this.table.colCount - 1)) : this.table.scenegraph.updateFrozenIcon(0, this.table.colCount - 1);
+    }
+    setFrozenRow(row) {
+        row !== this.frozen.row && (this.frozen.row = row, this.table.scenegraph.updateRowFrozen());
+    }
+    checkVerticalScrollBarEnd() {
+        var _a, _b;
+        const totalHeight = this.table.getAllRowsHeight(), scrollTop = this.scroll.verticalBarPos, viewHeight = this.table.tableNoFrameHeight;
+        scrollTop + viewHeight >= totalHeight && this.table.fireListeners(TABLE_EVENT_TYPE.SCROLL_VERTICAL_END, {
+            scrollTop: scrollTop,
+            scrollLeft: this.scroll.horizontalBarPos,
+            scrollHeight: null === (_a = this.table.theme.scrollStyle) || void 0 === _a ? void 0 : _a.width,
+            scrollWidth: null === (_b = this.table.theme.scrollStyle) || void 0 === _b ? void 0 : _b.width,
+            viewHeight: viewHeight,
+            viewWidth: this.table.tableNoFrameWidth
+        });
+    }
+    checkHorizontalScrollBarEnd() {
+        var _a, _b;
+        const totalWidth = this.table.getAllColsWidth(), scrollLeft = this.scroll.horizontalBarPos, viewWidth = this.table.tableNoFrameWidth;
+        scrollLeft + viewWidth >= totalWidth && this.table.fireListeners(TABLE_EVENT_TYPE.SCROLL_HORIZONTAL_END, {
+            scrollTop: this.scroll.verticalBarPos,
+            scrollLeft: scrollLeft,
+            scrollHeight: null === (_a = this.table.theme.scrollStyle) || void 0 === _a ? void 0 : _a.width,
+            scrollWidth: null === (_b = this.table.theme.scrollStyle) || void 0 === _b ? void 0 : _b.width,
+            viewHeight: this.table.tableNoFrameHeight,
+            viewWidth: viewWidth
+        });
+    }
+    updateVerticalScrollBar(yRatio) {
+        var _a, _b, _c, _d;
+        const totalHeight = this.table.getAllRowsHeight(), oldVerticalBarPos = this.scroll.verticalBarPos;
+        let verticalBarPos = Math.ceil(yRatio * (totalHeight - this.table.scenegraph.height));
+        isValid(verticalBarPos) && !isNaN(verticalBarPos) || (verticalBarPos = 0);
+        const dy = verticalBarPos - this.table.scenegraph.proxy.deltaY - oldVerticalBarPos;
+        if (this.table.fireListeners(TABLE_EVENT_TYPE.CAN_SCROLL, {
+            event: void 0,
+            scrollTop: verticalBarPos - this.table.scenegraph.proxy.deltaY,
+            scrollLeft: this.scroll.horizontalBarPos,
+            scrollHeight: null === (_a = this.table.theme.scrollStyle) || void 0 === _a ? void 0 : _a.width,
+            scrollWidth: null === (_b = this.table.theme.scrollStyle) || void 0 === _b ? void 0 : _b.width,
+            viewHeight: this.table.tableNoFrameHeight,
+            viewWidth: this.table.tableNoFrameWidth,
+            scrollDirection: "vertical",
+            scrollRatioY: yRatio,
+            dy: dy
+        }).some((value => !1 === value))) {
+            const yRatio = this.scroll.verticalBarPos / (totalHeight - this.table.scenegraph.height);
+            this.table.scenegraph.component.updateVerticalScrollBarPos(yRatio);
+        } else this.scroll.verticalBarPos = verticalBarPos, this.table.scenegraph.setY(-this.scroll.verticalBarPos, 1 === yRatio), 
+        this.scroll.verticalBarPos -= this.table.scenegraph.proxy.deltaY, this.table.scenegraph.proxy.deltaY = 0, 
+        this.updateHoverPos(-1, -1), this.table.fireListeners(TABLE_EVENT_TYPE.SCROLL, {
+            event: void 0,
+            scrollTop: this.scroll.verticalBarPos,
+            scrollLeft: this.scroll.horizontalBarPos,
+            scrollHeight: null === (_c = this.table.theme.scrollStyle) || void 0 === _c ? void 0 : _c.width,
+            scrollWidth: null === (_d = this.table.theme.scrollStyle) || void 0 === _d ? void 0 : _d.width,
+            viewHeight: this.table.tableNoFrameHeight,
+            viewWidth: this.table.tableNoFrameWidth,
+            scrollDirection: "vertical",
+            scrollRatioY: yRatio,
+            dy: dy
+        }), oldVerticalBarPos !== this.scroll.verticalBarPos && this.checkVerticalScrollBarEnd();
+    }
+    updateHorizontalScrollBar(xRatio) {
+        var _a, _b, _c, _d;
+        const totalWidth = this.table.getAllColsWidth(), oldHorizontalBarPos = this.scroll.horizontalBarPos;
+        let horizontalBarPos = Math.ceil(xRatio * (totalWidth - this.table.scenegraph.width));
+        isValid(horizontalBarPos) && !isNaN(horizontalBarPos) || (horizontalBarPos = 0);
+        const dx = horizontalBarPos - this.table.scenegraph.proxy.deltaX - oldHorizontalBarPos;
+        if (this.table.fireListeners(TABLE_EVENT_TYPE.CAN_SCROLL, {
+            event: void 0,
+            scrollTop: this.scroll.verticalBarPos,
+            scrollLeft: horizontalBarPos - this.table.scenegraph.proxy.deltaX,
+            scrollHeight: null === (_a = this.table.theme.scrollStyle) || void 0 === _a ? void 0 : _a.width,
+            scrollWidth: null === (_b = this.table.theme.scrollStyle) || void 0 === _b ? void 0 : _b.width,
+            viewHeight: this.table.tableNoFrameHeight,
+            viewWidth: this.table.tableNoFrameWidth,
+            scrollDirection: "horizontal",
+            scrollRatioX: xRatio,
+            dx: dx
+        }).some((value => !1 === value))) {
+            const xRatio = this.scroll.horizontalBarPos / (totalWidth - this.table.scenegraph.width);
+            this.table.scenegraph.component.updateHorizontalScrollBarPos(xRatio);
+        } else this.scroll.horizontalBarPos = horizontalBarPos, this.table.scenegraph.setX(-this.scroll.horizontalBarPos, 1 === xRatio), 
+        this.scroll.horizontalBarPos -= this.table.scenegraph.proxy.deltaX, this.table.scenegraph.proxy.deltaX = 0, 
+        this.updateHoverPos(-1, -1), this.table.fireListeners(TABLE_EVENT_TYPE.SCROLL, {
+            event: void 0,
+            scrollTop: this.scroll.verticalBarPos,
+            scrollLeft: this.scroll.horizontalBarPos,
+            scrollHeight: null === (_c = this.table.theme.scrollStyle) || void 0 === _c ? void 0 : _c.width,
+            scrollWidth: null === (_d = this.table.theme.scrollStyle) || void 0 === _d ? void 0 : _d.width,
+            viewHeight: this.table.tableNoFrameHeight,
+            viewWidth: this.table.tableNoFrameWidth,
+            scrollDirection: "horizontal",
+            scrollRatioX: xRatio,
+            dx: dx
+        }), oldHorizontalBarPos !== this.scroll.horizontalBarPos && this.checkHorizontalScrollBarEnd();
+    }
+    setScrollTop(top, event, triggerEvent = !0) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const totalHeight = this.table.getAllRowsHeight(), sizeTolerance = (null === (_a = this.table.options.customConfig) || void 0 === _a ? void 0 : _a._disableColumnAndRowSizeRound) ? 1 : 0;
+        top = Math.max(0, Math.min(top, totalHeight - this.table.scenegraph.height - sizeTolerance)), 
+        top = Math.ceil(top);
+        const oldVerticalBarPos = this.scroll.verticalBarPos, yRatio = top / (totalHeight - this.table.scenegraph.height);
+        if ((oldVerticalBarPos !== top || !0 === (null === (_c = null === (_b = this.table.options) || void 0 === _b ? void 0 : _b.customConfig) || void 0 === _c ? void 0 : _c.scrollEventAlwaysTrigger)) && triggerEvent) {
+            let verticalBarPos = top;
+            isValid(verticalBarPos) && !isNaN(verticalBarPos) || (verticalBarPos = 0);
+            const dy = verticalBarPos - oldVerticalBarPos;
+            if (this.table.fireListeners(TABLE_EVENT_TYPE.CAN_SCROLL, {
+                event: null == event ? void 0 : event.nativeEvent,
+                scrollTop: verticalBarPos,
+                scrollLeft: this.scroll.horizontalBarPos,
+                scrollHeight: null === (_d = this.table.theme.scrollStyle) || void 0 === _d ? void 0 : _d.width,
+                scrollWidth: null === (_e = this.table.theme.scrollStyle) || void 0 === _e ? void 0 : _e.width,
+                viewHeight: this.table.tableNoFrameHeight,
+                viewWidth: this.table.tableNoFrameWidth,
+                scrollDirection: "vertical",
+                scrollRatioY: yRatio,
+                dy: dy
+            }).some((value => !1 === value))) {
+                const yRatio = this.scroll.verticalBarPos / (totalHeight - this.table.scenegraph.height);
+                return void this.table.scenegraph.component.updateVerticalScrollBarPos(yRatio);
+            }
+        }
+        (top !== this.scroll.verticalBarPos || this.table.isPivotChart()) && this.updateHoverPos(-1, -1), 
+        this.scroll.verticalBarPos = top, isValid(this.scroll.verticalBarPos) && !isNaN(this.scroll.verticalBarPos) || (this.scroll.verticalBarPos = 0), 
+        this.table.scenegraph.setY(-top), this.table.scenegraph.component.updateVerticalScrollBarPos(yRatio);
+        const dy = this.scroll.verticalBarPos - oldVerticalBarPos;
+        this.table.fireListeners(TABLE_EVENT_TYPE.SCROLL, {
+            event: null == event ? void 0 : event.nativeEvent,
+            scrollTop: this.scroll.verticalBarPos,
+            scrollLeft: this.scroll.horizontalBarPos,
+            scrollHeight: null === (_f = this.table.theme.scrollStyle) || void 0 === _f ? void 0 : _f.width,
+            scrollWidth: null === (_g = this.table.theme.scrollStyle) || void 0 === _g ? void 0 : _g.width,
+            viewHeight: this.table.tableNoFrameHeight,
+            viewWidth: this.table.tableNoFrameWidth,
+            scrollDirection: "vertical",
+            scrollRatioY: yRatio,
+            dy: dy
+        }), oldVerticalBarPos !== top && triggerEvent && this.checkVerticalScrollBarEnd();
+    }
+    setScrollLeft(left, event, triggerEvent = !0) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        this.table.scrollLeft;
+        const totalWidth = this.table.getAllColsWidth(), sizeTolerance = (this.table.getFrozenColsWidth(), 
+        (null === (_a = this.table.options.customConfig) || void 0 === _a ? void 0 : _a._disableColumnAndRowSizeRound) ? 1 : 0);
+        left = Math.max(0, Math.min(left, totalWidth - this.table.scenegraph.width - sizeTolerance)), 
+        left = Math.ceil(left);
+        const oldHorizontalBarPos = this.scroll.horizontalBarPos, xRatio = left / (totalWidth - this.table.scenegraph.width);
+        if ((oldHorizontalBarPos !== left || !0 === (null === (_c = null === (_b = this.table.options) || void 0 === _b ? void 0 : _b.customConfig) || void 0 === _c ? void 0 : _c.scrollEventAlwaysTrigger)) && triggerEvent) {
+            let horizontalBarPos = left;
+            isValid(horizontalBarPos) && !isNaN(horizontalBarPos) || (horizontalBarPos = 0);
+            const dx = horizontalBarPos - oldHorizontalBarPos;
+            if (this.table.fireListeners(TABLE_EVENT_TYPE.CAN_SCROLL, {
+                event: null == event ? void 0 : event.nativeEvent,
+                scrollTop: this.scroll.verticalBarPos,
+                scrollLeft: horizontalBarPos,
+                scrollHeight: null === (_d = this.table.theme.scrollStyle) || void 0 === _d ? void 0 : _d.width,
+                scrollWidth: null === (_e = this.table.theme.scrollStyle) || void 0 === _e ? void 0 : _e.width,
+                viewHeight: this.table.tableNoFrameHeight,
+                viewWidth: this.table.tableNoFrameWidth,
+                scrollDirection: "horizontal",
+                scrollRatioX: xRatio,
+                dx: dx
+            }).some((value => !1 === value))) {
+                const xRatio = this.scroll.horizontalBarPos / (totalWidth - this.table.scenegraph.width);
+                return void this.table.scenegraph.component.updateHorizontalScrollBarPos(xRatio);
+            }
+        }
+        left !== this.scroll.horizontalBarPos && this.updateHoverPos(-1, -1), this.scroll.horizontalBarPos = left, 
+        isValid(this.scroll.horizontalBarPos) && !isNaN(this.scroll.horizontalBarPos) || (this.scroll.horizontalBarPos = 0), 
+        this.table.scenegraph.setX(-left), this.table.scenegraph.component.updateHorizontalScrollBarPos(xRatio);
+        const dx = this.scroll.horizontalBarPos - oldHorizontalBarPos;
+        this.table.fireListeners(TABLE_EVENT_TYPE.SCROLL, {
+            event: null == event ? void 0 : event.nativeEvent,
+            scrollTop: this.scroll.verticalBarPos,
+            scrollLeft: this.scroll.horizontalBarPos,
+            scrollHeight: null === (_f = this.table.theme.scrollStyle) || void 0 === _f ? void 0 : _f.width,
+            scrollWidth: null === (_g = this.table.theme.scrollStyle) || void 0 === _g ? void 0 : _g.width,
+            viewHeight: this.table.tableNoFrameHeight,
+            viewWidth: this.table.tableNoFrameWidth,
+            scrollDirection: "horizontal",
+            scrollRatioX: xRatio,
+            dx: dx
+        }), oldHorizontalBarPos !== left && triggerEvent && this.checkHorizontalScrollBarEnd();
+    }
+    hideVerticalScrollBar() {
+        this.table.scenegraph.component.hideVerticalScrollBar();
+    }
+    showVerticalScrollBar(autoHide) {
+        this.table.scenegraph.component.showVerticalScrollBar(), autoHide && (clearTimeout(this._clearVerticalScrollBar), 
+        this._clearVerticalScrollBar = setTimeout((() => {
+            var _a;
+            null === (_a = this.table.scenegraph) || void 0 === _a || _a.component.hideVerticalScrollBar();
+        }), 1e3));
+    }
+    hideHorizontalScrollBar() {
+        this.table.scenegraph.component.hideHorizontalScrollBar();
+    }
+    showHorizontalScrollBar(autoHide) {
+        this.table.scenegraph.component.showHorizontalScrollBar(), autoHide && (clearTimeout(this._clearHorizontalScrollBar), 
+        this._clearHorizontalScrollBar = setTimeout((() => {
+            var _a;
+            null === (_a = this.table.scenegraph) || void 0 === _a || _a.component.hideHorizontalScrollBar();
+        }), 1e3));
+    }
+    triggerContextMenu(col, row, x, y) {
+        this.menu.isShow && this.menu.x === x && this.menu.y === y ? this.hideMenu() : this.showContextMenu(col, row, x, y);
+    }
+    showContextMenu(col, row, x, y) {
+        var _a;
+        (null === (_a = this.table.internalProps.menu) || void 0 === _a ? void 0 : _a.contextMenuItems) && ("html" === this.table.internalProps.menu.renderMode ? this.menu.isShow = !0 : (this.menu.isShow = !0, 
+        this.menu.x = x, this.menu.y = y, this.table.scenegraph.component.menu.attach(x, y, col, row, MenuType.contextmenu)), 
+        this.table.fireListeners(TABLE_EVENT_TYPE.SHOW_MENU, {
+            x: x,
+            y: y,
+            col: col,
+            row: row,
+            type: "contextmenu"
+        }));
+    }
+    triggerDropDownMenu(col, row, x, y, event) {
+        this.table.fireListeners(TABLE_EVENT_TYPE.DROPDOWN_ICON_CLICK, {
+            col: col,
+            row: row,
+            event: event
+        }), this.menu.isShow ? this.hideMenu() : this.showDropDownMenu(col, row, x, y);
+    }
+    showDropDownMenu(col, row, x, y) {
+        "html" === this.table.internalProps.menu.renderMode ? this.menu.isShow = !0 : (this.menu.isShow = !0, 
+        this.table.scenegraph.component.menu.attach(x, y, col, row, MenuType.dropDown), 
+        this.menu.bounds = this.table.scenegraph.component.menu.bounds), this.table.fireListeners(TABLE_EVENT_TYPE.SHOW_MENU, {
+            x: x,
+            y: y,
+            col: col,
+            row: row,
+            type: "dropDown"
+        }), this.residentHoverIcon && this.table.scenegraph.setIconNormalStyle(this.residentHoverIcon.icon, this.residentHoverIcon.col, this.residentHoverIcon.row);
+        const cellGroup = this.table.scenegraph.getCell(col, row);
+        let icon;
+        cellGroup.forEachChildren((child => child.attribute.funcType === IconFuncTypeEnum.dropDown && (icon = child, 
+        !0))), icon && (this.residentHoverIcon = {
+            col: col,
+            row: row,
+            icon: icon
+        }, this.table.scenegraph.setIconHoverStyle(this.residentHoverIcon.icon, this.residentHoverIcon.col, this.residentHoverIcon.row, cellGroup), 
+        this.table.scenegraph.residentHoverIcon(col, row));
+    }
+    hideMenu() {
+        this.menu.isShow && (this.table.fireListeners(TABLE_EVENT_TYPE.DROPDOWN_MENU_CLEAR, null), 
+        this.table.fireListeners(TABLE_EVENT_TYPE.HIDE_MENU, null), this.menu.isShow = !1, 
+        this.table.scenegraph.component.menu.detach(), this.residentHoverIcon && (this.table.scenegraph.setIconNormalStyle(this.residentHoverIcon.icon, this.residentHoverIcon.col, this.residentHoverIcon.row), 
+        this.table.scenegraph.resetResidentHoverIcon(this.residentHoverIcon.col, this.residentHoverIcon.row), 
+        this.residentHoverIcon = null));
+    }
+    setDropDownMenuHighlight(dropDownMenuInfo) {
+        this.menu.dropDownMenuHighlight = dropDownMenuInfo;
+        for (let i = 0; i < dropDownMenuInfo.length; i++) {
+            const {col: col, row: row} = dropDownMenuInfo[i], range = this.table.getCellRange(col, row);
+            if (range) for (let col = range.start.col; col <= range.end.col; col++) for (let row = range.start.row; row <= range.end.row; row++) this.table.scenegraph.updateCellContent(col, row);
+        }
+    }
+    dropDownMenuIsHighlight(colNow, rowNow, index) {
+        const highlights = this.menu.dropDownMenuHighlight;
+        if (Array.isArray(highlights)) for (let i = 0; i < highlights.length; i++) {
+            const highlight = highlights[i];
+            let {col: col, row: row} = highlight;
+            const {field: field, menuKey: menuKey} = highlight;
+            if ("number" != typeof col || "number" != typeof row) if (this.table.isPivotTable() && (Array.isArray(field), 
+            1)) {
+                const cellAddress = this.table.internalProps.layoutMap.getPivotCellAdress(field);
+                if (!cellAddress) continue;
+                col = cellAddress.col, row = cellAddress.row;
+            } else {
+                const cellAddress = this.table.internalProps.layoutMap.getHeaderCellAddressByField(field);
+                if (!cellAddress) continue;
+                col = cellAddress.col, row = cellAddress.row;
+            }
+            if (isValid(col) && isValid(row) && this.table.isCellRangeEqual(colNow, rowNow, col, row)) {
+                let dropDownMenu = this.table._getHeaderLayoutMap(null != col ? col : colNow, null != row ? row : rowNow).dropDownMenu || this.table.globalDropDownMenu;
+                if ("function" == typeof dropDownMenu && (dropDownMenu = dropDownMenu({
+                    row: row,
+                    col: col,
+                    table: this.table
+                })), dropDownMenu) for (let i = 0; i < dropDownMenu.length; i++) {
+                    const item = dropDownMenu[i];
+                    if (isObject(item) && (item.menuKey || item.text) === (menuKey || "") && i === index) return !0;
+                    if (isString(item) && item === menuKey && i === index) return !0;
+                }
+            }
+        }
+        return !1;
+    }
+    triggerSort(col, row, iconMark, event) {
+        if (this.table.isPivotTable()) {
+            const sortState = this.table.getPivotSortState(col, row), order = sortState ? sortState.toUpperCase() : "NORMAL", new_order = "ASC" === order ? "DESC" : "DESC" === order ? "NORMAL" : "ASC";
+            return this.table.sort(col, row, new_order), void this.table.fireListeners(PIVOT_TABLE_EVENT_TYPE.PIVOT_SORT_CLICK, {
+                col: col,
+                row: row,
+                order: order || "normal",
+                dimensionInfo: this.table.internalProps.layoutMap.getPivotDimensionInfo(col, row),
+                cellLocation: this.table.getCellLocation(col, row),
+                event: event
+            });
+        }
+        const previousSort = [ ...this.sort ], previousSortItem = this.table.internalProps.multipleSort || !previousSort.length ? null : this.sort[this.sort.length - 1];
+        dealSort(col, row, this.table, event);
+        const range = this.table.getCellRange(col, row), currentSortItem = this.sort.find((item => item.col === range.start.col && item.row === range.start.row)), oldSortCol = this.table.internalProps.multipleSort || !previousSortItem ? null : previousSortItem.col, oldSortRow = this.table.internalProps.multipleSort || !previousSortItem ? null : previousSortItem.row, currentSortItemIndex = previousSort.findIndex((item => item.col === col && item.row === row));
+        currentSortItemIndex >= 0 && previousSort.splice(currentSortItemIndex, 1), this.table.scenegraph.updateSortIcon({
+            col: col,
+            row: row,
+            iconMark: iconMark,
+            order: null == currentSortItem ? void 0 : currentSortItem.order,
+            oldSortCol: oldSortCol,
+            oldSortRow: oldSortRow,
+            oldIconMark: null == previousSortItem ? void 0 : previousSortItem.icon
+        }), currentSortItem && (currentSortItem.icon = iconMark), this.table.internalProps.multipleSort || previousSort.forEach((sortItem => {
+            this.table.scenegraph.updateSortIcon({
+                col: null,
+                row: null,
+                iconMark: null,
+                order: "normal",
+                oldSortCol: sortItem.col,
+                oldSortRow: sortItem.row,
+                oldIconMark: null
+            });
+        })), this.table.fireListeners(PIVOT_TABLE_EVENT_TYPE.AFTER_SORT, {
+            order: null == currentSortItem ? void 0 : currentSortItem.order,
+            field: this.table.getHeaderField(col, row),
+            event: event
+        });
+    }
+    updateSortState(sortState) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        sortState = Array.isArray(sortState) ? sortState : [ sortState ];
+        for (let index = 0; index < sortState.length; index++) {
+            if (sortState[index].field === (null === (_a = this.sort[index]) || void 0 === _a ? void 0 : _a.field) && sortState[sortState.length - 1].order === (null === (_b = this.sort[index]) || void 0 === _b ? void 0 : _b.order)) return;
+            const oldSortCol = this.table.internalProps.multipleSort ? null : (null === (_c = this.sort[index]) || void 0 === _c ? void 0 : _c.col) || null, oldSortRow = this.table.internalProps.multipleSort ? null : (null === (_d = this.sort[index]) || void 0 === _d ? void 0 : _d.row) || null;
+            "asc" === (null === (_e = this.sort[index]) || void 0 === _e ? void 0 : _e.order) || (null === (_f = this.sort[index]) || void 0 === _f || _f.order);
+            this.setSortState(sortState.slice(0, index + 1));
+            const cellAddress = this.table.internalProps.layoutMap.getHeaderCellAddressByField(sortState[index].field);
+            this.sort[index].col = cellAddress.col, this.sort[index].row = cellAddress.row;
+            const cellGroup = this.table.scenegraph.getCell(this.sort[index].col, this.sort[index].row);
+            let iconMark;
+            traverseObject(cellGroup, "children", (mark => "sort" === mark.attribute.funcType && (iconMark = mark, 
+            !0))), this.table.scenegraph.updateSortIcon({
+                col: this.sort[index].col,
+                row: this.sort[index].row,
+                iconMark: iconMark,
+                order: this.sort[index].order,
+                oldSortCol: oldSortCol,
+                oldSortRow: oldSortRow,
+                oldIconMark: null === (_g = this.sort[index]) || void 0 === _g ? void 0 : _g.icon
+            });
+        }
+        const normalHeaders = [];
+        this.table.internalProps.layoutMap.columnTree.tree.children.forEach((item => {
+            sortState.some((state => state.field === item.field)) || normalHeaders.push(item);
+        }));
+        for (let index = 0; index < normalHeaders.length; index++) {
+            const column = normalHeaders[index];
+            this.table.scenegraph.updateSortIcon({
+                col: null,
+                row: null,
+                iconMark: null,
+                order: null,
+                oldSortCol: null !== (_h = column.startInTotal + this.table.internalProps.layoutMap.leftRowSeriesNumberColumnCount) && void 0 !== _h ? _h : 0,
+                oldSortRow: column.level,
+                oldIconMark: null
+            });
+        }
+    }
+    triggerFreeze(col, row, iconMark) {
+        if (!this.table.isPivotTable() && !this.table.transpose) {
+            if (dealFreeze(col, row, this.table), this.table.hasListeners(PIVOT_TABLE_EVENT_TYPE.FREEZE_CLICK)) {
+                const fields = this.table.internalProps.layoutMap.columnObjects.slice(0, col + 1);
+                this.table.fireListeners(PIVOT_TABLE_EVENT_TYPE.FREEZE_CLICK, {
+                    col: col,
+                    row: row,
+                    fields: fields.reduce(((pre, cur) => pre.concat(cur.field)), []),
+                    colCount: this.table.frozenColCount
+                });
+            }
+            this.frozen.icon = iconMark;
+        }
+    }
+    updateCursor(mode = "default") {
+        this.table.getElement().style.cursor = mode;
+    }
+    updateDrillState(dimensionKey, title, drillDown, drillUp, col, row) {
+        this.drill.dimensionKey = dimensionKey, this.drill.title = title, this.drill.drillDown = drillDown, 
+        this.drill.drillUp = drillUp, this.drill.col = col, this.drill.row = row, updateDrill(col, row, drillDown, drillUp, this.table);
+    }
+    updateSparklineHoverPose(col, row, x, y) {
+        -1 !== this.sparkLine.col && -1 !== this.sparkLine.row && clearChartHover(this.sparkLine.col, this.sparkLine.row, this.table);
+        let isUpdated = !1;
+        -1 !== col && -1 !== row && (isUpdated = updateChartHover(col, row, x, y, this.table)), 
+        isUpdated ? (this.sparkLine.col = col, this.sparkLine.row = row) : (this.sparkLine.col = -1, 
+        this.sparkLine.row = -1);
+    }
+    setCheckedState(col, row, field, checked) {
+        return setCheckedState(col, row, field, checked, this);
+    }
+    setHeaderCheckedState(field, checked) {
+        return setHeaderCheckedState(field, checked, this);
+    }
+    syncCheckedState(col, row, field, checked) {
+        return syncCheckedState(col, row, field, checked, this);
+    }
+    initCheckedState(records) {
+        return initCheckedState(records, this);
+    }
+    updateHeaderCheckedState(field, col, row) {
+        return updateHeaderCheckedState(field, this, col, row);
+    }
+    initLeftRecordsCheckState(records) {
+        return initLeftRecordsCheckState(records, this);
+    }
+    setRadioState(col, row, field, radioType, indexInCell) {
+        setRadioState(col, row, field, radioType, indexInCell, this);
+    }
+    syncRadioState(col, row, field, radioType, indexInCell, isChecked) {
+        return syncRadioState(col, row, field, radioType, indexInCell, isChecked, this);
+    }
+    changeCheckboxAndRadioOrder(sourceIndex, targetIndex) {
+        this.checkedState.size && changeCheckboxOrder(sourceIndex, targetIndex, this), this.radioState.length && changeRadioOrder(sourceIndex, targetIndex, this);
+    }
+    setCustomSelectRanges(customSelectRanges) {
+        deletaCustomSelectRanges(this), addCustomSelectRanges(customSelectRanges, this);
+    }
+}
+//# sourceMappingURL=state.js.map