@visactor/vtable 0.9.0-alpha.0-alpha.0

package/es/core/BaseTable.js

@@ -0,0 +1,1281 @@
+import * as columnStyleContents from "../body-helper/style";
+
+import * as headerStyleContents from "../header-helper/style";
+
+import "../tools/style.css";
+
+import * as style from "../tools/style";
+
+import { event, style as utilStyle } from "../tools/helper";
+
+import { TABLE_EVENT_TYPE } from "./TABLE_EVENT_TYPE";
+
+import { EventHandler } from "../event/EventHandler";
+
+import { EventTarget } from "../event/EventTarget";
+
+import { NumberMap } from "../tools/NumberMap";
+
+import { Rect } from "../tools/Rect";
+
+import { defaultOrderFn, isValid, throttle2 } from "../tools/util";
+
+import themes from "../themes";
+
+import { Env } from "../tools/env";
+
+import { Scenegraph } from "../scenegraph/scenegraph";
+
+import { StateManeger } from "../state/state";
+
+import { EventManeger } from "../event/event";
+
+import { BodyHelper } from "../body-helper/body-helper";
+
+import { HeaderHelper } from "../header-helper/header-helper";
+
+import { TooltipHandler } from "../tooltip/TooltipHandler";
+
+import { WrapText } from "../scenegraph/graphic/text";
+
+import { textMeasure } from "../scenegraph/utils/measure-text";
+
+import { getStyleTheme } from "../scenegraph/group-creater/column-helper";
+
+import { getProp } from "../scenegraph/utils/get-prop";
+
+import { IconCache } from "../plugins/icons";
+
+import { _applyColWidthLimits, _getScrollableVisibleRect, _getTargetFrozenColAt, _getTargetFrozenRowAt, _setDataSource, _setRecords, _toPxWidth, createRootElement, isAutoDefine, updateRootElementPadding } from "./tableHelper";
+
+import { MenuHandler } from "../menu/dom/MenuHandler";
+
+import { FocusInput } from "./FouseInput";
+
+const {toBoxArray: toBoxArray} = utilStyle, {isTouchEvent: isTouchEvent} = event, rangeReg = /^\$(\d+)\$(\d+)$/;
+
+export class BaseTable extends EventTarget {
+    static get EVENT_TYPE() {
+        return TABLE_EVENT_TYPE;
+    }
+    constructor(options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        super(), this.showPin = !0, this.showSort = !0, this.id = `VTable${Date.now()}`, 
+        this.throttleInvalidate = throttle2(this.invalidate.bind(this), 200);
+        const {frozenColCount: frozenColCount = 0, defaultRowHeight: defaultRowHeight = 40, defaultHeaderRowHeight: defaultHeaderRowHeight, defaultColWidth: defaultColWidth = 80, defaultHeaderColWidth: defaultHeaderColWidth, widthMode: widthMode = "standard", keyboardOptions: keyboardOptions, parentElement: parentElement, columnResizeMode: columnResizeMode, dragHeaderMode: dragHeaderMode, showPin: showPin, allowFrozenColCount: allowFrozenColCount, padding: padding, hover: hover, menu: menu, select: click, customRender: customRender, pixelRatio: pixelRatio = 1} = options;
+        this.options = options, this._widthMode = widthMode, this.customRender = customRender, 
+        this.padding = {
+            top: 0,
+            right: 0,
+            left: 0,
+            bottom: 0
+        }, padding && ("number" == typeof padding ? (this.padding.top = padding, this.padding.left = padding, 
+        this.padding.bottom = padding, this.padding.right = padding) : (padding.top && (this.padding.top = padding.top), 
+        padding.bottom && (this.padding.bottom = padding.bottom), padding.left && (this.padding.left = padding.left), 
+        padding.right && (this.padding.right = padding.right))), this.tableNoFrameWidth = 0, 
+        this.tableNoFrameHeight = 0;
+        const internalProps = this.internalProps = {};
+        void 0 !== showPin && (this.showPin = showPin), "number" == typeof allowFrozenColCount && allowFrozenColCount <= 0 && (this.showPin = !1), 
+        internalProps.autoRowHeight = null !== (_a = options.autoRowHeight) && void 0 !== _a && _a, 
+        internalProps.handler = new EventHandler, internalProps.element = createRootElement(this.padding), 
+        internalProps.focusControl = new FocusInput(this, internalProps.element), internalProps.pixelRatio = pixelRatio, 
+        internalProps.canvas = document.createElement("canvas"), internalProps.element.appendChild(internalProps.canvas), 
+        internalProps.context = internalProps.canvas.getContext("2d"), internalProps.frozenColCount = frozenColCount, 
+        internalProps.defaultRowHeight = defaultRowHeight, internalProps.defaultHeaderRowHeight = null != defaultHeaderRowHeight ? defaultHeaderRowHeight : defaultRowHeight, 
+        internalProps.defaultColWidth = defaultColWidth, internalProps.defaultHeaderColWidth = null != defaultHeaderColWidth ? defaultHeaderColWidth : defaultColWidth, 
+        internalProps.keyboardOptions = keyboardOptions, internalProps.columnResizeMode = columnResizeMode, 
+        internalProps.dragHeaderMode = dragHeaderMode, internalProps._rowHeightsMap = new NumberMap, 
+        internalProps._rowRangeHeightsMap = new Map, internalProps._colRangeWidthsMap = new Map, 
+        this.colWidthsMap = new NumberMap, this.colContentWidthsMap = new NumberMap, this.colWidthsLimit = {}, 
+        internalProps.calcWidthContext = {
+            _: internalProps,
+            get full() {
+                var _a;
+                return this._.canvas.width / (null !== (_a = this._.context.pixelRatio) && void 0 !== _a ? _a : window.devicePixelRatio);
+            }
+        }, internalProps.cellTextOverflows = {}, internalProps.focusedTable = !1, internalProps.theme = themes.of(null !== (_b = options.theme) && void 0 !== _b ? _b : themes.DEFAULT), 
+        parentElement ? (parentElement.innerHTML = "", parentElement.appendChild(internalProps.element), 
+        this._updateSize()) : this._updateSize(), this._cellToBeInvalidatedNextFrame = new Set, 
+        this._willNextFrameInvalidate = !1, this.options = options, internalProps.theme = themes.of(null !== (_c = options.theme) && void 0 !== _c ? _c : themes.DEFAULT), 
+        internalProps.bodyHelper = new BodyHelper(this), internalProps.headerHelper = new HeaderHelper(this), 
+        internalProps.autoWrapText = options.autoWrapText, internalProps.allowFrozenColCount = null !== (_d = options.allowFrozenColCount) && void 0 !== _d ? _d : internalProps.colCount, 
+        internalProps.limitMaxAutoWidth = null !== (_e = options.limitMaxAutoWidth) && void 0 !== _e ? _e : 450, 
+        this.scenegraph = new Scenegraph(this), this.stateManeger = new StateManeger(this), 
+        this.eventManeger = new EventManeger(this), internalProps.tooltip = Object.assign({
+            renderMode: "html",
+            isShowOverflowTextTooltip: !1,
+            confine: !0
+        }, options.tooltip), "html" === internalProps.tooltip.renderMode && (internalProps.tooltipHandler = new TooltipHandler(this, internalProps.tooltip.confine)), 
+        internalProps.menu = Object.assign({
+            renderMode: "html"
+        }, options.menu), Array.isArray(null === (_f = options.menu) || void 0 === _f ? void 0 : _f.dropDownMenuHighlight) && this.setDropDownMenuHighlight(null === (_g = options.menu) || void 0 === _g ? void 0 : _g.dropDownMenuHighlight), 
+        Array.isArray(null === (_h = options.menu) || void 0 === _h ? void 0 : _h.defaultHeaderMenuItems) && (this.globalDropDownMenu = options.menu.defaultHeaderMenuItems), 
+        "html" === internalProps.menu.renderMode && (internalProps.menuHandler = new MenuHandler(this)), 
+        this.headerStyleCache = new Map, this.bodyStyleCache = new Map;
+    }
+    getParentElement() {
+        return this.options.parentElement;
+    }
+    getElement() {
+        return this.internalProps.element;
+    }
+    get canvas() {
+        return this.internalProps.canvas;
+    }
+    get rowCount() {
+        return this.internalProps.rowCount;
+    }
+    set rowCount(rowCount) {
+        this.internalProps.rowCount = rowCount;
+    }
+    get colCount() {
+        var _a;
+        return null !== (_a = this.internalProps.colCount) && void 0 !== _a ? _a : 0;
+    }
+    set colCount(colCount) {
+        this.internalProps.colCount = colCount;
+    }
+    get frozenColCount() {
+        var _a;
+        return null !== (_a = this.internalProps.frozenColCount) && void 0 !== _a ? _a : 0;
+    }
+    set frozenColCount(frozenColCount) {
+        frozenColCount >= this.colCount && (frozenColCount = 0), this.internalProps.frozenColCount = frozenColCount, 
+        this.options.frozenColCount = frozenColCount, this.tableNoFrameWidth - this.getColsWidth(0, frozenColCount - 1) <= 120 && (this.internalProps.frozenColCount = 0), 
+        this.stateManeger.setFrozenCol(this.internalProps.frozenColCount);
+    }
+    setFrozenColCount(frozenColCount) {
+        frozenColCount >= this.colCount && (frozenColCount = 0), this.internalProps.frozenColCount = frozenColCount, 
+        this.options.frozenColCount = frozenColCount, this.tableNoFrameWidth - this.getColsWidth(0, frozenColCount - 1) <= 120 && (this.internalProps.frozenColCount = 0), 
+        this.stateManeger.setFrozenCol(this.internalProps.frozenColCount);
+    }
+    _setFrozenColCount(frozenColCount) {
+        frozenColCount >= this.colCount && (frozenColCount = 0), this.internalProps.frozenColCount = frozenColCount;
+    }
+    _resetFrozenColCount() {
+        this.options.frozenColCount && (this.tableNoFrameWidth - this.getColsWidth(0, this.options.frozenColCount - 1) <= 120 ? this._setFrozenColCount(0) : this.frozenColCount !== this.options.frozenColCount && this._setFrozenColCount(this.options.frozenColCount));
+    }
+    get frozenRowCount() {
+        var _a;
+        return null !== (_a = this.internalProps.frozenRowCount) && void 0 !== _a ? _a : 0;
+    }
+    set frozenRowCount(frozenRowCount) {
+        this.internalProps.frozenRowCount = frozenRowCount;
+    }
+    get defaultRowHeight() {
+        return this.internalProps.defaultRowHeight;
+    }
+    set defaultRowHeight(defaultRowHeight) {
+        this.internalProps.defaultRowHeight = defaultRowHeight, this.options.defaultRowHeight = defaultRowHeight;
+    }
+    get defaultHeaderRowHeight() {
+        return this.internalProps.defaultHeaderRowHeight;
+    }
+    set defaultHeaderRowHeight(defaultHeaderRowHeight) {
+        this.internalProps.defaultHeaderRowHeight = defaultHeaderRowHeight, this.options.defaultHeaderRowHeight = defaultHeaderRowHeight;
+    }
+    get defaultColWidth() {
+        return this.internalProps.defaultColWidth;
+    }
+    set defaultColWidth(defaultColWidth) {
+        this.internalProps.defaultColWidth = defaultColWidth, this.options.defaultColWidth = defaultColWidth;
+    }
+    get defaultHeaderColWidth() {
+        return this.internalProps.defaultHeaderColWidth;
+    }
+    set defaultHeaderColWidth(defaultHeaderColWidth) {
+        this.internalProps.defaultHeaderColWidth = defaultHeaderColWidth, this.options.defaultHeaderColWidth = defaultHeaderColWidth;
+    }
+    get colWidthsMap() {
+        return this.internalProps._colWidthsMap;
+    }
+    set colWidthsMap(colWidthsMap) {
+        this.internalProps._colWidthsMap = colWidthsMap;
+    }
+    get colContentWidthsMap() {
+        return this.internalProps._colContentWidthsMap;
+    }
+    set colContentWidthsMap(colContentWidthsMap) {
+        this.internalProps._colContentWidthsMap = colContentWidthsMap;
+    }
+    get _colRangeWidthsMap() {
+        return this.internalProps._colRangeWidthsMap;
+    }
+    set _colRangeWidthsMap(_colRangeWidthsMap) {
+        this.internalProps._colRangeWidthsMap = _colRangeWidthsMap;
+    }
+    get _rowRangeHeightsMap() {
+        return this.internalProps._rowRangeHeightsMap;
+    }
+    set _rowRangeHeightsMap(_rowRangeHeightsMap) {
+        this.internalProps._rowRangeHeightsMap = _rowRangeHeightsMap;
+    }
+    get rowHeightsMap() {
+        return this.internalProps._rowHeightsMap;
+    }
+    set rowHeightsMap(rowHeightsMap) {
+        this.internalProps._rowHeightsMap = rowHeightsMap;
+    }
+    get colWidthsLimit() {
+        return this.internalProps._colWidthsLimit;
+    }
+    set colWidthsLimit(colWidthsLimit) {
+        this.internalProps._colWidthsLimit = colWidthsLimit;
+    }
+    get keyboardOptions() {
+        var _a;
+        return null !== (_a = this.internalProps.keyboardOptions) && void 0 !== _a ? _a : null;
+    }
+    set keyboardOptions(keyboardOptions) {
+        this.internalProps.keyboardOptions = null != keyboardOptions ? keyboardOptions : void 0;
+    }
+    get widthMode() {
+        return this._widthMode;
+    }
+    set widthMode(widthMode) {
+        widthMode !== this._widthMode && (this._widthMode = widthMode);
+    }
+    _colWidthDefineToPxWidth(width) {
+        return isAutoDefine(width) ? _toPxWidth(this, this._calculateAutoColWidthExpr()) : _toPxWidth(this, width);
+    }
+    _calculateAutoColWidthExpr() {
+        const fullWidth = this.internalProps.calcWidthContext.full;
+        let sumMin = 0;
+        const others = [];
+        let autoCount = 0;
+        const hasLimitsOnAuto = [];
+        for (let col = 0; col < this.internalProps.colCount; col++) {
+            const def = this.getColWidthDefine(col), limits = this._getColWidthLimits(col);
+            if (isAutoDefine(def)) limits && (hasLimitsOnAuto.push(limits), limits.min && (sumMin += limits.min)), 
+            autoCount++; else {
+                let expr = def;
+                if (limits) {
+                    const orgWidth = _toPxWidth(this, expr), newWidth = _applyColWidthLimits(limits, orgWidth);
+                    orgWidth !== newWidth && (expr = `${newWidth}px`), sumMin += newWidth;
+                }
+                others.push(expr);
+            }
+            if (sumMin > fullWidth) return "0px";
+        }
+        if (hasLimitsOnAuto.length && others.length) {
+            const autoPx = (fullWidth - _toPxWidth(this, `calc(${others.map((c => "number" == typeof c ? `${c}px` : c)).join(" + ")})`)) / autoCount;
+            if (hasLimitsOnAuto.forEach((limits => {
+                limits.min && autoPx < limits.min ? (others.push(limits.minDef), autoCount--) : limits.max && limits.max < autoPx && (others.push(limits.maxDef), 
+                autoCount--);
+            })), autoCount <= 0) return `${autoPx}px`;
+        }
+        if (others.length) {
+            const strDefs = [];
+            let num = 0;
+            return others.forEach((c => {
+                "number" == typeof c ? num += c : strDefs.push(c);
+            })), strDefs.push(`${num}px`), `calc((100% - (${strDefs.join(" + ")})) / ${autoCount})`;
+        }
+        return 100 / autoCount + "%";
+    }
+    _getColWidthLimits(col) {
+        const limit = this.colWidthsLimit[col];
+        if (!limit) return null;
+        const result = {};
+        return limit.min && (result.min = _toPxWidth(this, limit.min), result.minDef = limit.min), 
+        limit.max && (result.max = _toPxWidth(this, limit.max), result.maxDef = limit.max), 
+        result;
+    }
+    _adjustColWidth(col, orgWidth) {
+        const limits = this._getColWidthLimits(col);
+        return Math.max(_applyColWidthLimits(limits, orgWidth), 0);
+    }
+    setPixelRatio(pixelRatio) {}
+    _updateSize() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
+        const {padding: padding} = this;
+        let widthP = 0, heightP = 0;
+        if ("browser" === Env.mode) {
+            const element = this.getElement(), width1 = null !== (_b = null === (_a = element.parentElement) || void 0 === _a ? void 0 : _a.offsetWidth) && void 0 !== _b ? _b : 0, height1 = null !== (_d = null === (_c = element.parentElement) || void 0 === _c ? void 0 : _c.offsetHeight) && void 0 !== _d ? _d : 0;
+            element.style.width = width1 && width1 - padding.left - padding.right + "px" || "0px", 
+            element.style.height = height1 && height1 - padding.top - padding.bottom + "px" || "0px";
+            const {canvas: canvas} = this.internalProps;
+            canvas.style.width = "", canvas.style.height = "", widthP = null !== (_f = null === (_e = canvas.parentElement) || void 0 === _e ? void 0 : _e.offsetWidth) && void 0 !== _f ? _f : 0, 
+            heightP = null !== (_h = null === (_g = canvas.parentElement) || void 0 === _g ? void 0 : _g.offsetHeight) && void 0 !== _h ? _h : 0, 
+            canvas.width = widthP, canvas.height = heightP, canvas.style.width = `${widthP}px`, 
+            canvas.style.height = `${heightP}px`;
+        } else "node" === Env.mode && (widthP = this.canvasWidth - 1, heightP = this.canvasHeight - 1);
+        const width = Math.floor(widthP - style.getScrollBarSize(this.getTheme().scrollStyle)), height = Math.floor(heightP - style.getScrollBarSize(this.getTheme().scrollStyle));
+        if (null === (_j = this.internalProps.theme) || void 0 === _j ? void 0 : _j.frameStyle) {
+            const lineWidths = toBoxArray(null !== (_l = null === (_k = this.internalProps.theme.frameStyle) || void 0 === _k ? void 0 : _k.borderLineWidth) && void 0 !== _l ? _l : [ null ]), shadowWidths = toBoxArray(null !== (_o = null === (_m = this.internalProps.theme.frameStyle) || void 0 === _m ? void 0 : _m.shadowBlur) && void 0 !== _o ? _o : [ 0 ]);
+            this.tableX = (null !== (_p = lineWidths[3]) && void 0 !== _p ? _p : 0) + (null !== (_q = shadowWidths[3]) && void 0 !== _q ? _q : 0), 
+            this.tableY = (null !== (_r = lineWidths[0]) && void 0 !== _r ? _r : 0) + (null !== (_s = shadowWidths[0]) && void 0 !== _s ? _s : 0), 
+            this.tableNoFrameWidth = width - ((null !== (_t = lineWidths[1]) && void 0 !== _t ? _t : 0) + (null !== (_u = shadowWidths[1]) && void 0 !== _u ? _u : 0)) - ((null !== (_v = lineWidths[3]) && void 0 !== _v ? _v : 0) + (null !== (_w = shadowWidths[3]) && void 0 !== _w ? _w : 0)), 
+            this.tableNoFrameHeight = height - ((null !== (_x = lineWidths[0]) && void 0 !== _x ? _x : 0) + (null !== (_y = shadowWidths[0]) && void 0 !== _y ? _y : 0)) - ((null !== (_z = lineWidths[2]) && void 0 !== _z ? _z : 0) + (null !== (_0 = shadowWidths[2]) && void 0 !== _0 ? _0 : 0));
+        }
+    }
+    get rowHierarchyType() {
+        return "grid";
+    }
+    setColWidths(widths) {
+        widths.forEach(((value, index) => this.setColWidth(index, value)));
+    }
+    getColsWidth(startCol, endCol) {
+        var _a;
+        endCol = Math.min(endCol, this.colCount - 1);
+        const cachedColWidth = this._colRangeWidthsMap.get(`$${startCol}$${endCol}`);
+        if (null != cachedColWidth) return cachedColWidth;
+        const cachedLowerColWidth = this._colRangeWidthsMap.get(`$${startCol}$${endCol - 1}`);
+        if (null != cachedLowerColWidth) {
+            const width = this.colWidthsMap.get(endCol);
+            let adjustW;
+            adjustW = width ? "adaptive" === this.widthMode || this.transpose ? Number(width) : this._adjustColWidth(endCol, this._colWidthDefineToPxWidth(width)) : 0;
+            const addWidth = cachedLowerColWidth + adjustW;
+            return startCol >= 0 && endCol >= 0 && !Number.isNaN(addWidth) && this._colRangeWidthsMap.set(`$${startCol}$${endCol}`, Math.round(addWidth)), 
+            Math.round(addWidth);
+        }
+        let w = 0;
+        for (let col = startCol; col <= endCol; col++) w += this.isRowHeader(col, 0) || this.isCornerHeader(col, 0) ? Array.isArray(this.defaultHeaderColWidth) ? null !== (_a = this.defaultHeaderColWidth[col]) && void 0 !== _a ? _a : this.internalProps.defaultColWidth : this.defaultHeaderColWidth : this.internalProps.defaultColWidth;
+        this.colWidthsMap.each(startCol, endCol, ((width, col) => {
+            var _a;
+            w += ("adaptive" === this.widthMode || this.transpose ? Number(width) : this._adjustColWidth(col, this._colWidthDefineToPxWidth(width))) - (this.isRowHeader(col, 0) || this.isCornerHeader(col, 0) ? Array.isArray(this.defaultHeaderColWidth) ? null !== (_a = this.defaultHeaderColWidth[col]) && void 0 !== _a ? _a : this.internalProps.defaultColWidth : this.defaultHeaderColWidth : this.internalProps.defaultColWidth);
+        }));
+        for (let col = startCol; col <= endCol; col++) {
+            if (this.colWidthsMap.has(col)) continue;
+            const adj = this._adjustColWidth(col, this.internalProps.defaultColWidth);
+            adj !== this.internalProps.defaultColWidth && (w += adj - this.internalProps.defaultColWidth);
+        }
+        return startCol >= 0 && endCol >= 0 && this._colRangeWidthsMap.set(`$${startCol}$${endCol}`, Math.round(w)), 
+        Math.round(w);
+    }
+    getRowHeight(row) {
+        var _a;
+        return this.rowHeightsMap.get(row) || (this.isColumnHeader(0, row) || this.isCornerHeader(0, row) ? Array.isArray(this.defaultHeaderRowHeight) ? null !== (_a = this.defaultHeaderRowHeight[row]) && void 0 !== _a ? _a : this.internalProps.defaultRowHeight : this.defaultHeaderRowHeight : this.internalProps.defaultRowHeight);
+    }
+    setRowHeight(row, height, clearCache) {
+        this.rowHeightsMap.put(row, Math.round(height)), clearCache && this._clearRowRangeHeightsMap(row);
+    }
+    fillRowsHeight(rowStart, rowEnd, rowHeight) {
+        var _a;
+        for (let row = rowStart; row <= rowEnd; row++) this.rowHeightsMap.put(row, Math.round(rowHeight)), 
+        this._rowRangeHeightsMap.set(`$0$${row}`, Math.round((null !== (_a = this._rowRangeHeightsMap.get("$0$" + (row - 1))) && void 0 !== _a ? _a : 0) + rowHeight));
+    }
+    getRowsHeight(startRow, endRow) {
+        var _a, _b, _c;
+        const cachedRowHeight = this._rowRangeHeightsMap.get(`$${startRow}$${endRow}`);
+        if (null != cachedRowHeight) return cachedRowHeight;
+        const cachedLowerRowHeight = this._rowRangeHeightsMap.get(`$${startRow}$${endRow - 1}`);
+        if (null != cachedLowerRowHeight) {
+            const height = Math.round(cachedLowerRowHeight + (null !== (_a = this.rowHeightsMap.get(endRow)) && void 0 !== _a ? _a : this.isColumnHeader(0, endRow) || this.isCornerHeader(0, endRow) ? Array.isArray(this.defaultHeaderRowHeight) ? null !== (_b = this.defaultHeaderRowHeight[endRow]) && void 0 !== _b ? _b : this.internalProps.defaultRowHeight : this.defaultHeaderRowHeight : this.internalProps.defaultRowHeight));
+            return startRow >= 0 && endRow >= 0 && this._rowRangeHeightsMap.set(`$${startRow}$${endRow}`, Math.round(height)), 
+            height;
+        }
+        let h = 0;
+        for (let i = startRow; i <= endRow; i++) h += this.rowHeightsMap.get(i) || (this.isColumnHeader(0, i) || this.isCornerHeader(0, i) ? Array.isArray(this.defaultHeaderRowHeight) ? null !== (_c = this.defaultHeaderRowHeight[i]) && void 0 !== _c ? _c : this.internalProps.defaultRowHeight : this.defaultHeaderRowHeight : this.internalProps.defaultRowHeight);
+        return startRow >= 0 && endRow >= 0 && h > 0 && this._rowRangeHeightsMap.set(`$${startRow}$${endRow}`, Math.round(h)), 
+        Math.round(h);
+    }
+    getColWidthDefine(col) {
+        var _a;
+        const width = this.colWidthsMap.get(col);
+        return "number" == typeof width && width <= 0 ? 0 : width || (this.isRowHeader(col, 0) || this.isCornerHeader(col, 0) ? Array.isArray(this.defaultHeaderColWidth) ? null !== (_a = this.defaultHeaderColWidth[col]) && void 0 !== _a ? _a : this.defaultColWidth : this.defaultHeaderColWidth : this.defaultColWidth);
+    }
+    getColWidth(col) {
+        const width = this.getColWidthDefine(col);
+        return "adaptive" === this.widthMode && "number" == typeof width || this.transpose && "number" == typeof width ? this._colWidthDefineToPxWidth(width) : this._adjustColWidth(col, this._colWidthDefineToPxWidth(width));
+    }
+    setColWidth(col, width, clearCache, skipCheckFrozen) {
+        this.colWidthsMap.put(col, "number" == typeof width ? Math.round(width) : width), 
+        clearCache && this._clearColRangeWidthsMap(col), skipCheckFrozen || this.stateManeger.checkFrozen();
+    }
+    _clearColRangeWidthsMap(col) {
+        if ("number" != typeof col) this._colRangeWidthsMap.clear(); else {
+            const keys = this._colRangeWidthsMap.keys();
+            for (const key of keys) {
+                const reg = rangeReg.exec(key);
+                if (reg) {
+                    const start = Number(reg[1]), end = Number(reg[2]);
+                    col >= start && col <= end && this._colRangeWidthsMap.delete(key);
+                }
+            }
+        }
+    }
+    _clearRowRangeHeightsMap(row) {
+        const keys = this._rowRangeHeightsMap.keys();
+        for (const key of keys) {
+            const reg = rangeReg.exec(key);
+            if (reg) {
+                const start = Number(reg[1]), end = Number(reg[2]);
+                row >= start && row <= end && this._rowRangeHeightsMap.delete(key);
+            }
+        }
+    }
+    _getColContentWidth(col) {
+        return Number(this.colContentWidthsMap.get(col));
+    }
+    _setColContentWidth(col, width) {
+        this.colContentWidthsMap.put(col, width);
+    }
+    getAllRowsHeight() {
+        if (this.internalProps.rowCount <= 0) return 0;
+        return this.getRowsHeight(0, this.internalProps.rowCount - 1);
+    }
+    getAllColsWidth() {
+        if (this.internalProps.colCount <= 0) return 0;
+        return this.getColsWidth(0, this.internalProps.colCount - 1);
+    }
+    getMaxColWidth(col) {
+        var _a;
+        const obj = this.colWidthsLimit[col];
+        let max = null !== (_a = obj && obj.max) && void 0 !== _a ? _a : 1 / 0;
+        return "string" == typeof max && (max = _toPxWidth(this, max)), max;
+    }
+    setMaxColWidth(col, maxwidth) {
+        (this.colWidthsLimit[col] || (this.colWidthsLimit[col] = {})).max = maxwidth;
+    }
+    getMinColWidth(col) {
+        var _a;
+        const obj = this.colWidthsLimit[col];
+        let min = null !== (_a = obj && obj.min) && void 0 !== _a ? _a : 0;
+        return "string" == typeof min && (min = _toPxWidth(this, min)), min;
+    }
+    setMinColWidth(col, minwidth) {
+        (this.colWidthsLimit[col] || (this.colWidthsLimit[col] = {})).min = minwidth;
+    }
+    getCellRect(col, row) {
+        const isFrozenCell = this.isFrozenCell(col, row);
+        let absoluteLeft = this.getColsWidth(0, col - 1) || 0;
+        const width = this.getColWidth(col);
+        isFrozenCell && isFrozenCell.col && (absoluteLeft += this.scrollLeft);
+        let absoluteTop = this.getRowsHeight(0, row - 1);
+        const height = this.getRowHeight(row);
+        return isFrozenCell && isFrozenCell.row && (absoluteTop += this.scrollTop), new Rect(Math.round(absoluteLeft), Math.round(absoluteTop), Math.round(width), Math.round(height));
+    }
+    getMergeCellRect(col, row) {
+        const cellRange = this.getCellRange(col, row), absoluteLeft = this.getColsWidth(0, cellRange.start.col - 1) || 0, width = this.getColsWidth(cellRange.start.col, cellRange.end.col), absoluteTop = this.getRowsHeight(0, cellRange.start.row - 1) || 0, height = this.getRowsHeight(cellRange.start.row, cellRange.end.row);
+        return new Rect(Math.round(absoluteLeft), Math.round(absoluteTop), Math.round(width), Math.round(height));
+    }
+    getCellRelativeRect(col, row) {
+        return this._toRelativeRect(this.getCellRect(col, row));
+    }
+    getCellRangeRelativeRect(range) {
+        if (range.start) return this._toRelativeRect(this.getCellsRect(range.start.col, range.start.row, range.end.col, range.end.row));
+        const cellRange = this.getCellRange(range.col, range.row);
+        return this._toRelativeRect(this.getCellsRect(cellRange.start.col, cellRange.start.row, cellRange.end.col, cellRange.end.row));
+    }
+    getVisibleCellRangeRelativeRect(range) {
+        let cellRange;
+        return cellRange = range.start ? range : this.getCellRange(range.col, range.row), 
+        this._getVisiableRect(this.getCellRangeRelativeRect(range), cellRange);
+    }
+    _getVisiableRect(relativeRectObj, cellRange) {
+        const targetLeft = cellRange.start.col >= this.frozenColCount ? Math.max(relativeRectObj.left, this.frozenColCount >= 1 ? this.getColsWidth(0, this.frozenColCount - 1) : 0) : relativeRectObj.left, targetRight = Math.min(relativeRectObj.right, this.tableNoFrameWidth), rect = relativeRectObj.copy();
+        rect.left = targetLeft, rect.right = targetRight;
+        const targetTop = cellRange.start.row >= this.frozenRowCount ? Math.max(relativeRectObj.top, this.frozenRowCount >= 1 ? this.getRowsHeight(0, this.frozenRowCount - 1) : 0) : relativeRectObj.top, targetBottom = Math.min(relativeRectObj.bottom, this.tableNoFrameHeight);
+        return rect.top = targetTop, rect.bottom = targetBottom, rect;
+    }
+    getCellsRect(startCol, startRow, endCol, endRow) {
+        const isFrozenStartCell = this.isFrozenCell(startCol, startRow), isFrozenEndCell = this.isFrozenCell(endCol, endRow);
+        let absoluteLeft = this.getColsWidth(0, startCol - 1) || 0, width = this.getColsWidth(startCol, endCol);
+        if (isFrozenStartCell && isFrozenStartCell.col) {
+            const scrollLeft = this.scrollLeft;
+            absoluteLeft += scrollLeft, isFrozenEndCell && isFrozenEndCell.col || (width -= scrollLeft, 
+            width = Math.max(width, this.getColsWidth(startCol, this.frozenColCount - 1)));
+        }
+        let absoluteTop = this.getRowsHeight(0, startRow - 1), height = this.getRowsHeight(startRow, endRow);
+        if (isFrozenStartCell && isFrozenStartCell.row) {
+            const scrollTop = this.scrollTop;
+            absoluteTop += scrollTop, isFrozenEndCell && isFrozenEndCell.row || (height -= scrollTop, 
+            height = Math.max(height, this.getRowsHeight(startRow, this.frozenRowCount - 1)));
+        }
+        return new Rect(Math.round(absoluteLeft), Math.round(absoluteTop), Math.round(width), Math.round(height));
+    }
+    getCellsRectWidth(startCol, startRow, endCol, endRow) {
+        const isFrozenStartCell = this.isFrozenCell(startCol, startRow), isFrozenEndCell = this.isFrozenCell(endCol, endRow);
+        let width = this.getColsWidth(startCol, endCol);
+        if (isFrozenStartCell && isFrozenStartCell.col) {
+            const scrollLeft = this.scrollLeft;
+            isFrozenEndCell && isFrozenEndCell.col || (width -= scrollLeft, width = Math.max(width, this.getColsWidth(startCol, this.frozenColCount - 1)));
+        }
+        return width;
+    }
+    getCellRangeRect(range) {
+        if (range.start) return this.getCellsRect(range.start.col, range.start.row, range.end.col, range.end.row);
+        const cellRange = this.getCellRange(range.col, range.row);
+        return this.getCellsRect(cellRange.start.col, cellRange.start.row, cellRange.end.col, cellRange.end.row);
+    }
+    getCellRangeRectWidth(range) {
+        if (range.start) return this.getCellsRectWidth(range.start.col, range.start.row, range.end.col, range.end.row);
+        const cellRange = this.getCellRange(range.col, range.row);
+        return this.getCellsRectWidth(cellRange.start.col, cellRange.start.row, cellRange.end.col, cellRange.end.row);
+    }
+    isFrozenCell(col, row) {
+        const {frozenRowCount: frozenRowCount, frozenColCount: frozenColCount} = this.internalProps, isFrozenRow = frozenRowCount > 0 && row < frozenRowCount, isFrozenCol = frozenColCount > 0 && col < frozenColCount;
+        return isFrozenRow || isFrozenCol ? {
+            row: isFrozenRow,
+            col: isFrozenCol
+        } : null;
+    }
+    getRowAt(absoluteY) {
+        const frozen = _getTargetFrozenRowAt(this, absoluteY);
+        if (frozen) return frozen;
+        let row = this.getTargetRowAt(absoluteY);
+        return row || (row = {
+            top: -1,
+            row: -1,
+            bottom: -1,
+            height: -1
+        }), row;
+    }
+    getColAt(absoluteX) {
+        const frozen = _getTargetFrozenColAt(this, absoluteX);
+        if (frozen) return frozen;
+        let col = this.getTargetColAt(absoluteX);
+        return col || (col = {
+            left: -1,
+            col: -1,
+            right: -1,
+            width: 1
+        }), col;
+    }
+    getCellAt(absoluteX, absoluteY) {
+        const rowInfo = this.getRowAt(absoluteY), {row: row, top: top, bottom: bottom, height: height} = rowInfo, colInfo = this.getColAt(absoluteX), {col: col, left: left, right: right, width: width} = colInfo;
+        return {
+            row: row,
+            col: col,
+            rect: {
+                left: left,
+                right: right,
+                top: top,
+                bottom: bottom,
+                width: width,
+                height: height
+            }
+        };
+    }
+    _checkRowCol(col, row) {
+        return col >= 0 && col < this.colCount && row >= 0 && row < this.rowCount;
+    }
+    _makeVisibleCell(col, row) {
+        if (this._checkRowCol(col, row)) {
+            const isFrozenCell = this.isFrozenCell(col, row);
+            if (isFrozenCell && isFrozenCell.col && isFrozenCell.row) return;
+            const rect = this.getCellRect(col, row), visibleRect = _getScrollableVisibleRect(this);
+            if (visibleRect.contains(rect)) return;
+            isFrozenCell && isFrozenCell.col || this.getColsWidth(0, this.frozenColCount - 1) + rect.width > this.canvas.width || (rect.left < visibleRect.left ? this.scrollLeft -= visibleRect.left - rect.left : visibleRect.right < rect.right && (this.scrollLeft -= visibleRect.right - rect.right)), 
+            isFrozenCell && isFrozenCell.row || this.getRowsHeight(0, this.frozenRowCount - 1) + rect.height > this.canvas.height || (rect.top < visibleRect.top ? this.scrollTop -= visibleRect.top - rect.top : visibleRect.bottom < rect.bottom && (this.scrollTop -= visibleRect.bottom - rect.bottom));
+        }
+    }
+    invalidate() {
+        this.scenegraph.renderSceneGraph();
+    }
+    _toRelativeRect(absoluteRect) {
+        const rect = absoluteRect.copy(), visibleRect = this.getVisibleRect();
+        return rect.offsetLeft(-visibleRect.left), rect.offsetTop(-visibleRect.top), rect;
+    }
+    getVisibleRect() {
+        const {scrollTop: scrollTop, scrollLeft: scrollLeft} = this, width = this.tableNoFrameWidth, height = this.tableNoFrameHeight;
+        return new Rect(scrollLeft, scrollTop, width, height);
+    }
+    get visibleRowCount() {
+        const {frozenRowCount: frozenRowCount} = this, visibleRect = this.getVisibleRect(), visibleTop = frozenRowCount > 0 ? visibleRect.top + this.getRowsHeight(0, frozenRowCount - 1) : visibleRect.top, initRow = this.getTargetRowAt(visibleTop);
+        if (!initRow) return 0;
+        const startRow = Math.max(initRow.top >= visibleTop ? initRow.row : initRow.row + 1, frozenRowCount);
+        let absoluteTop = this.getRowsHeight(0, startRow - 1), count = 0;
+        const {rowCount: rowCount} = this;
+        for (let row = startRow; row < rowCount; row++) {
+            const bottom = absoluteTop + this.getRowHeight(row);
+            if (visibleRect.bottom < bottom) break;
+            count++, absoluteTop = bottom;
+        }
+        return count;
+    }
+    get visibleColCount() {
+        const {frozenColCount: frozenColCount} = this, visibleRect = this.getVisibleRect(), visibleLeft = frozenColCount > 0 ? visibleRect.left + this.getColsWidth(0, frozenColCount - 1) : visibleRect.left, initCol = this.getTargetColAt(visibleLeft);
+        if (!initCol) return 0;
+        const startCol = Math.max(initCol.left >= visibleLeft ? initCol.col : initCol.col + 1, frozenColCount);
+        let absoluteLeft = this.getColsWidth(0, startCol - 1), count = 0;
+        const {colCount: colCount} = this;
+        for (let col = startCol; col < colCount; col++) {
+            const right = absoluteLeft + this.getColWidth(col);
+            if (visibleRect.right < right) break;
+            count++, absoluteLeft = right;
+        }
+        return count;
+    }
+    get scrollTop() {
+        return this.stateManeger.scroll.verticalBarPos;
+    }
+    set scrollTop(scrollTop) {
+        this.stateManeger.setScrollTop(scrollTop);
+    }
+    get scrollLeft() {
+        return this.stateManeger.scroll.horizontalBarPos;
+    }
+    set scrollLeft(scrollLeft) {
+        this.stateManeger.setScrollLeft(scrollLeft);
+    }
+    getScrollLeft() {
+        return this.scrollLeft;
+    }
+    getScrollTop() {
+        return this.scrollTop;
+    }
+    setScrollLeft(num) {
+        this.scrollLeft = num;
+    }
+    setScrollTop(num) {
+        this.scrollTop = num;
+    }
+    getCellOverflowText(col, row) {
+        return this.scenegraph.getCellOverflowText(col, row);
+    }
+    addDisposable(disposable) {
+        if (!disposable || !disposable.dispose || "function" != typeof disposable.dispose) throw new Error("not disposable!");
+        (this.internalProps.disposables = this.internalProps.disposables || []).push(disposable);
+    }
+    dispose() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const internalProps = this.internalProps;
+        null === (_b = null === (_a = internalProps.tooltipHandler) || void 0 === _a ? void 0 : _a.dispose) || void 0 === _b || _b.call(_a), 
+        null === (_d = null === (_c = internalProps.menuHandler) || void 0 === _c ? void 0 : _c.dispose) || void 0 === _d || _d.call(_c), 
+        IconCache.clearAll(), null === (_e = super.dispose) || void 0 === _e || _e.call(this), 
+        null === (_g = null === (_f = internalProps.handler) || void 0 === _f ? void 0 : _f.dispose) || void 0 === _g || _g.call(_f), 
+        null === (_j = null === (_h = internalProps.focusControl) || void 0 === _h ? void 0 : _h.dispose) || void 0 === _j || _j.call(_h), 
+        internalProps.disposables && (internalProps.disposables.forEach((disposable => {
+            var _a;
+            return null === (_a = null == disposable ? void 0 : disposable.dispose) || void 0 === _a ? void 0 : _a.call(disposable);
+        })), internalProps.disposables = null), this.scenegraph.stage.release();
+        const {parentElement: parentElement} = internalProps.element;
+        parentElement && parentElement.removeChild(internalProps.element);
+    }
+    fireListeners(type, ...event) {
+        return super.fireListeners(type, ...event);
+    }
+    updateOption(options) {
+        var _a, _b, _c, _d;
+        this.options = options;
+        const {frozenColCount: frozenColCount = 0, defaultRowHeight: defaultRowHeight = 40, defaultHeaderRowHeight: defaultHeaderRowHeight, defaultColWidth: defaultColWidth = 80, defaultHeaderColWidth: defaultHeaderColWidth = 80, keyboardOptions: keyboardOptions, columnResizeMode: columnResizeMode, dragHeaderMode: dragHeaderMode, showPin: showPin, allowFrozenColCount: allowFrozenColCount, padding: padding, hover: hover, menu: menu, select: click, pixelRatio: pixelRatio, widthMode: widthMode} = options;
+        pixelRatio && pixelRatio !== this.internalProps.pixelRatio && (this.internalProps.pixelRatio = pixelRatio), 
+        padding && ("number" == typeof padding ? (this.padding.top = padding, this.padding.left = padding, 
+        this.padding.bottom = padding, this.padding.right = padding) : (padding.top && (this.padding.top = padding.top), 
+        padding.bottom && (this.padding.bottom = padding.bottom), padding.left && (this.padding.left = padding.left), 
+        padding.right && (this.padding.right = padding.right))), this.showPin = "boolean" != typeof showPin || showPin, 
+        "number" == typeof allowFrozenColCount && allowFrozenColCount <= 0 && (this.showPin = !1), 
+        this.widthMode = null != widthMode ? widthMode : "standard";
+        const internalProps = this.internalProps;
+        "node" !== Env.mode && updateRootElementPadding(internalProps.element, this.padding), 
+        internalProps.frozenColCount = frozenColCount, internalProps.defaultRowHeight = defaultRowHeight, 
+        internalProps.defaultHeaderRowHeight = null != defaultHeaderRowHeight ? defaultHeaderRowHeight : defaultRowHeight, 
+        internalProps.defaultColWidth = defaultColWidth, internalProps.defaultHeaderColWidth = null != defaultHeaderColWidth ? defaultHeaderColWidth : defaultColWidth, 
+        internalProps.keyboardOptions = keyboardOptions, internalProps.columnResizeMode = columnResizeMode, 
+        internalProps.dragHeaderMode = dragHeaderMode, internalProps.cellTextOverflows = {}, 
+        internalProps.theme = themes.of(null !== (_a = options.theme) && void 0 !== _a ? _a : themes.DEFAULT), 
+        internalProps.autoRowHeight = null !== (_b = options.autoRowHeight) && void 0 !== _b && _b, 
+        internalProps.autoWrapText = options.autoWrapText, internalProps.allowFrozenColCount = null !== (_c = options.allowFrozenColCount) && void 0 !== _c ? _c : internalProps.colCount, 
+        internalProps.limitMaxAutoWidth = null !== (_d = options.limitMaxAutoWidth) && void 0 !== _d ? _d : 450, 
+        internalProps.tooltip = Object.assign({
+            renderMode: "html",
+            isShowOverflowTextTooltip: !1,
+            confine: !0
+        }, options.tooltip), "html" !== internalProps.tooltip.renderMode || internalProps.tooltipHandler || (internalProps.tooltipHandler = new TooltipHandler(this, internalProps.tooltip.confine)), 
+        internalProps.menu = Object.assign({
+            renderMode: "html"
+        }, options.menu), "html" !== internalProps.menu.renderMode || internalProps.menuHandler || (internalProps.menuHandler = new MenuHandler(this));
+    }
+    getFrozenRowsHeight() {
+        return this.getRowsHeight(0, this.frozenRowCount - 1);
+    }
+    getFrozenColsWidth() {
+        return this.getColsWidth(0, this.frozenColCount - 1);
+    }
+    getDrawRange() {
+        const width = Math.min(this.tableNoFrameWidth, this.getAllColsWidth()), height = Math.min(this.tableNoFrameHeight, this.getAllRowsHeight());
+        return new Rect(this.tableX, this.tableY, width, height);
+    }
+    _getMouseAbstractPoint(evt, isAddScroll = !0) {
+        let e;
+        if (!evt) return null;
+        e = isTouchEvent(evt) ? evt.changedTouches[0] : evt;
+        const clientX = e.clientX || e.pageX + window.scrollX, clientY = e.clientY || e.pageY + window.scrollY, rect = this.internalProps.canvas.getBoundingClientRect();
+        if (rect.right <= clientX) return null;
+        if (rect.bottom <= clientY) return null;
+        const currentWidth = rect.width, widthRatio = currentWidth / (this.canvas.offsetWidth || currentWidth), currentHeight = rect.height, heightRatio = currentHeight / (this.canvas.offsetHeight || currentHeight);
+        return {
+            x: (clientX - rect.left) / widthRatio + (isAddScroll ? this.scrollLeft : 0) - this.tableX,
+            y: (clientY - rect.top) / heightRatio + (isAddScroll ? this.scrollTop : 0) - this.tableY
+        };
+    }
+    _getCellEventArgsSet(e) {
+        const abstractPos = this._getMouseAbstractPoint(e);
+        if (!abstractPos) return {};
+        const cell = this.getCellAt(abstractPos.x, abstractPos.y);
+        if (cell.col < 0 || cell.row < 0) return {
+            abstractPos: abstractPos,
+            cell: cell
+        };
+        return {
+            abstractPos: abstractPos,
+            cell: cell,
+            eventArgs: {
+                col: cell.col,
+                row: cell.row,
+                event: e,
+                rect: cell.rect
+            }
+        };
+    }
+    getTheme() {
+        return this.internalProps.theme;
+    }
+    getTargetColAt(absoluteX) {
+        if (0 === absoluteX) return {
+            left: 0,
+            col: 0,
+            right: 0,
+            width: 0
+        };
+        const findAfter = (startCol, startRight) => {
+            let left = startRight - this.getColWidth(startCol);
+            const {colCount: colCount} = this.internalProps;
+            for (let col = startCol; col < colCount; col++) {
+                const width = this.getColWidth(col), right = left + width;
+                if (Math.round(left) <= Math.round(absoluteX) && Math.round(absoluteX) < Math.round(right)) return {
+                    left: left,
+                    col: col,
+                    right: right,
+                    width: width
+                };
+                left = right;
+            }
+            return null;
+        }, candCol = this.computeTargetColByX(absoluteX), right = this.getColsWidth(0, candCol);
+        return absoluteX >= right ? findAfter(candCol, right) : ((startCol, startRight) => {
+            let right = startRight;
+            for (let col = startCol; col >= 0; col--) {
+                const width = this.getColWidth(col), left = right - width;
+                if (Math.round(left) <= Math.round(absoluteX) && Math.round(absoluteX) < Math.round(right)) return {
+                    left: left,
+                    col: col,
+                    right: right,
+                    width: width
+                };
+                right = left;
+            }
+            return null;
+        })(candCol, right);
+    }
+    getTargetRowAt(absoluteY) {
+        if (0 === absoluteY) return {
+            top: 0,
+            row: 0,
+            bottom: 0,
+            height: 0
+        };
+        const findAfter = (startRow, startBottom) => {
+            let top = startBottom - this.getRowHeight(startRow);
+            const {rowCount: rowCount} = this.internalProps;
+            for (let row = startRow; row < rowCount; row++) {
+                const height = this.getRowHeight(row), bottom = top + height;
+                if (Math.round(top) <= Math.round(absoluteY) && Math.round(absoluteY) < Math.round(bottom)) return {
+                    top: top,
+                    row: row,
+                    bottom: bottom,
+                    height: height
+                };
+                top = bottom;
+            }
+            return null;
+        }, candRow = this.computeTargetRowByY(absoluteY), bottom = this.getRowsHeight(0, candRow);
+        return absoluteY >= bottom ? findAfter(candRow, bottom) : ((startRow, startBottom) => {
+            let bottom = startBottom;
+            for (let row = startRow; row >= 0; row--) {
+                const height = this.getRowHeight(row), top = bottom - height;
+                if (Math.round(top) <= Math.round(absoluteY) && Math.round(absoluteY) < Math.round(bottom)) return {
+                    top: top,
+                    row: row,
+                    bottom: bottom,
+                    height: height
+                };
+                bottom = top;
+            }
+            return null;
+        })(candRow, bottom);
+    }
+    computeTargetRowByY(absoluteY) {
+        if (this._rowRangeHeightsMap.get("$0$" + (this.rowCount - 1))) {
+            let startRow = 0, endRow = this.rowCount - 1;
+            for (;endRow - startRow > 1; ) {
+                const midRow = Math.floor((startRow + endRow) / 2);
+                if (absoluteY < this._rowRangeHeightsMap.get(`$0$${midRow}`)) endRow = midRow; else {
+                    if (!(absoluteY > this._rowRangeHeightsMap.get(`$0$${midRow}`))) return midRow;
+                    startRow = midRow;
+                }
+            }
+            return endRow;
+        }
+        return Math.min(Math.ceil(absoluteY / this.internalProps.defaultRowHeight), this.rowCount - 1);
+    }
+    computeTargetColByX(absoluteX) {
+        if (this._colRangeWidthsMap.get("$0$" + (this.colCount - 1))) {
+            let startCol = 0, endCol = this.colCount - 1;
+            for (;endCol - startCol > 1; ) {
+                const midCol = Math.floor((startCol + endCol) / 2);
+                if (absoluteX < this._colRangeWidthsMap.get(`$0$${midCol}`)) endCol = midCol; else {
+                    if (!(absoluteX > this._colRangeWidthsMap.get(`$0$${midCol}`))) return midCol;
+                    startCol = midCol;
+                }
+            }
+            return endCol;
+        }
+        return Math.min(Math.ceil(absoluteX / this.internalProps.defaultColWidth), this.colCount - 1);
+    }
+    clearSelected() {}
+    selectCell(col, row) {}
+    updatePager(cof) {
+        this.pagerConf && ("number" == typeof cof.currentPage && cof.currentPage >= 0 && (this.pagerConf.currentPage = cof.currentPage), 
+        cof.perPageCount && (this.pagerConf.perPageCount = cof.perPageCount || this.pagerConf.perPageCount), 
+        this.scenegraph.clearCells(), this.dataSource.updatePager(this.pagerConf), this.refreshRowColCount(), 
+        this.scenegraph.createSceneGraph(), this.invalidate());
+    }
+    get allowFrozenColCount() {
+        return this.internalProps.allowFrozenColCount;
+    }
+    get rowHeaderLevelCount() {
+        return this.internalProps.layoutMap.rowHeaderLevelCount;
+    }
+    get columnHeaderLevelCount() {
+        return this.internalProps.layoutMap.columnHeaderLevelCount;
+    }
+    get records() {
+        return this.internalProps.records || null;
+    }
+    get dataSource() {
+        return this.internalProps.dataSource;
+    }
+    set dataSource(dataSource) {
+        this.scenegraph.clearCells(), _setDataSource(this, dataSource), this.refreshRowColCount(), 
+        this.scenegraph.createSceneGraph(), this.invalidate();
+    }
+    get autoWrapText() {
+        return this.internalProps.autoWrapText;
+    }
+    set autoWrapText(autoWrapText) {
+        this.internalProps.autoWrapText !== autoWrapText && (this.internalProps.autoWrapText = autoWrapText, 
+        this.options.autoWrapText = autoWrapText, this.internalProps.layoutMap && (this.refreshHeader(), 
+        this.invalidate()));
+    }
+    get theme() {
+        return this.internalProps.theme;
+    }
+    set theme(theme) {
+        const t = themes.of(theme);
+        this.internalProps.theme = t || themes.DEFAULT, this.options.theme = theme, this._updateSize(), 
+        this._resetFrozenColCount(), this.invalidate();
+    }
+    getBodyField(col, row) {
+        return this.internalProps.layoutMap.getBody(col, row).field;
+    }
+    getBodyColumnDefine(col, row) {
+        const body = this.internalProps.layoutMap.getBody(col, row);
+        return null == body ? void 0 : body.define;
+    }
+    getBodyColumnType(col, row) {
+        return this.internalProps.layoutMap.getBody(col, row).columnType;
+    }
+    getHeaderField(col, row) {
+        return this.internalProps.layoutMap.getHeaderField(col, row);
+    }
+    getHeaderFieldKey(col, row) {
+        return this.internalProps.layoutMap.getHeaderFieldKey(col, row);
+    }
+    getHeaderDefine(col, row) {
+        const hd = this.internalProps.layoutMap.getHeader(col, row);
+        return null == hd ? void 0 : hd.define;
+    }
+    getCellType(col, row) {
+        return this.internalProps.layoutMap.getCellType(col, row);
+    }
+    getCellHeaderPaths(col, row) {
+        return this.internalProps.layoutMap.getCellHeaderPaths(col, row);
+    }
+    getHeadersDefine(col, row) {
+        const headers = [];
+        for (;;) {
+            const header = this.getHeaderDefine(col, row);
+            if (!header || !header.field && !header.columns) break;
+            headers.push(header), row++;
+        }
+        return headers;
+    }
+    _getHeaderLayoutMap(col, row) {
+        return this.internalProps.layoutMap.getHeader(col, row);
+    }
+    _getBodyLayoutMap(col, row) {
+        return this.internalProps.layoutMap.getBody(col, row);
+    }
+    getContext() {
+        return this.internalProps.context;
+    }
+    getRecordByRowCol(col, row) {
+        var _a;
+        if (!this.internalProps.layoutMap.isHeader(col, row)) return null === (_a = this.internalProps.dataSource) || void 0 === _a ? void 0 : _a.get(this.getRecordIndexByRow(col, row));
+    }
+    getRecordStartRowByRecordIndex(index) {
+        return this.internalProps.layoutMap.getRecordStartRowByRecordIndex(index);
+    }
+    _getHeaderCellBySortState(sortState) {
+        const {layoutMap: layoutMap} = this.internalProps;
+        let hd;
+        if (hd = sortState.fieldKey ? layoutMap.headerObjects.find((col => col && col.fieldKey === sortState.fieldKey)) : layoutMap.headerObjects.find((col => col && col.field === sortState.field)), 
+        hd) {
+            return layoutMap.getHeaderCellAdress(hd.id);
+        }
+    }
+    getCellRange(col, row) {
+        return this.internalProps.layoutMap.getCellRange(col, row);
+    }
+    isCellRangeEqual(col, row, targetCol, targetRow) {
+        return this.internalProps.layoutMap.isCellRangeEqual(col, row, targetCol, targetRow);
+    }
+    _getLayoutCellId(col, row) {
+        return this.internalProps.layoutMap.getCellId(col, row);
+    }
+    getHeaderDescription(col, row) {
+        var _a;
+        const field = this._getHeaderLayoutMap(col, row), fieldDef = null == field ? void 0 : field.define, description = null !== (_a = null == fieldDef ? void 0 : fieldDef.description) && void 0 !== _a ? _a : null == field ? void 0 : field.description;
+        if ("function" == typeof description) {
+            return description({
+                col: col,
+                row: row,
+                value: this.getCellValue(col, row),
+                dataValue: this.getCellOriginValue(col, row)
+            });
+        }
+        return description;
+    }
+    setRecords(records, sort) {
+        var _a, _b;
+        const time = "undefined" != typeof window ? window.performance.now() : 0;
+        if (this.scenegraph.clearCells(), void 0 !== sort && (this.sortState = sort, this.stateManeger.setSortState(this.sortState)), 
+        records) {
+            if (_setRecords(this, records), this.sortState) {
+                let order, field, fieldKey;
+                if (Array.isArray(this.sortState) ? 0 !== this.sortState.length && ({order: order, field: field, fieldKey: fieldKey} = null === (_a = this.sortState) || void 0 === _a ? void 0 : _a[0]) : ({order: order, field: field, fieldKey: fieldKey} = this.sortState), 
+                order && field && "normal" !== order) {
+                    const sortFunc = this.getSortFuncFromHeaderOption(void 0, field, fieldKey);
+                    let hd;
+                    hd = fieldKey ? this.internalProps.layoutMap.headerObjects.find((col => col && col.fieldKey === fieldKey)) : this.internalProps.layoutMap.headerObjects.find((col => col && col.field === field)), 
+                    (null === (_b = null == hd ? void 0 : hd.define) || void 0 === _b ? void 0 : _b.sort) && this.dataSource.sort(hd.field, order, null != sortFunc ? sortFunc : defaultOrderFn);
+                }
+            }
+            this.refreshRowColCount();
+        } else _setRecords(this, records);
+        this.scenegraph.createSceneGraph(), this.invalidate(), console.log("setRecords cost time:", ("undefined" != typeof window ? window.performance.now() : 0) - time);
+    }
+    setDropDownMenuHighlight(cells) {
+        this.stateManeger.setDropDownMenuHighlight(cells);
+    }
+    _dropDownMenuIsHighlight(colNow, rowNow, index) {
+        return this.stateManeger.dropDownMenuIsHighlight(colNow, rowNow, index);
+    }
+    isHeader(col, row) {
+        return this.internalProps.layoutMap && this.internalProps.layoutMap.isHeader(col, row);
+    }
+    isColumnHeader(col, row) {
+        var _a;
+        return null === (_a = this.internalProps.layoutMap) || void 0 === _a ? void 0 : _a.isColumnHeader(col, row);
+    }
+    isRowHeader(col, row) {
+        var _a;
+        return null === (_a = this.internalProps.layoutMap) || void 0 === _a ? void 0 : _a.isRowHeader(col, row);
+    }
+    isCornerHeader(col, row) {
+        var _a;
+        return null === (_a = this.internalProps.layoutMap) || void 0 === _a ? void 0 : _a.isCornerHeader(col, row);
+    }
+    getCellInfo(col, row) {
+        const colDef = this.isHeader(col, row) ? this.getHeaderDefine(col, row) : this.getBodyColumnDefine(col, row);
+        return {
+            col: col,
+            row: row,
+            field: this.getHeaderField(col, row),
+            cellHeaderPaths: this.internalProps.layoutMap.getCellHeaderPaths(col, row),
+            caption: colDef.caption,
+            columnType: colDef.columnType ? "string" == typeof colDef.columnType ? colDef.columnType : "progressbar" : "text",
+            originData: this.getCellOriginRecord(col, row),
+            cellRange: this.getCellRangeRelativeRect({
+                col: col,
+                row: row
+            }),
+            value: this.getCellValue(col, row),
+            dataValue: this.getCellOriginValue(col, row),
+            cellType: this.getCellType(col, row),
+            scaleRatio: this.canvas.getBoundingClientRect().width / this.canvas.offsetWidth
+        };
+    }
+    _hasField(field, col, row) {
+        if (null == field) return !1;
+        if (this.internalProps.layoutMap.isHeader(col, row)) return !1;
+        const index = this.getRecordIndexByRow(col, row);
+        return this.internalProps.dataSource.hasField(index, field);
+    }
+    _getCellStyle(col, row) {
+        const {layoutMap: layoutMap} = this.internalProps;
+        if (layoutMap.isHeader(col, row)) {
+            let cacheStyle = this.headerStyleCache.get(`${col}-${row}`);
+            if (cacheStyle) return cacheStyle;
+            const hd = layoutMap.getHeader(col, row), styleClass = this.internalProps.headerHelper.getStyleClass(hd.headerType), {style: style} = hd;
+            return cacheStyle = headerStyleContents.of(style, layoutMap.isColumnHeader(col, row) ? this.theme.headerStyle : layoutMap.isRowHeader(col, row) ? this.theme.rowHeaderStyle : this.theme.cornerHeaderStyle, {
+                col: col,
+                row: row,
+                table: this,
+                value: this.getCellValue(col, row),
+                dataValue: this.getCellOriginValue(col, row),
+                cellHeaderPaths: this.getCellHeaderPaths(col, row)
+            }, styleClass, this.options.autoWrapText), this.headerStyleCache.set(`${col}-${row}`, cacheStyle), 
+            cacheStyle;
+        }
+        let cacheKey;
+        cacheKey = this.isListTable() && !this.transpose || this.isPivotTable() && this.internalProps.layoutMap.indicatorsAsCol ? col : row;
+        let cacheStyle = this.bodyStyleCache.get(cacheKey);
+        if (cacheStyle) return cacheStyle;
+        const column = layoutMap.getBody(col, row), styleClass = this.internalProps.bodyHelper.getStyleClass(column.columnType), style = null == column ? void 0 : column.style;
+        return cacheStyle = columnStyleContents.of(style, this.theme.bodyStyle, {
+            col: col,
+            row: row,
+            table: this,
+            value: this.getCellValue(col, row),
+            dataValue: this.getCellOriginValue(col, row),
+            cellHeaderPaths: this.getCellHeaderPaths(col, row)
+        }, styleClass, this.options.autoWrapText), this.bodyStyleCache.set(cacheKey, cacheStyle), 
+        cacheStyle;
+    }
+    _canResizeColumn(col, row) {
+        if (!(col >= 0 && row >= 0)) return !1;
+        if (this.isCellRangeEqual(col, row, col + 1, row)) return !1;
+        if ("none" === this.internalProps.columnResizeMode) return !1;
+        if ("header" === this.internalProps.columnResizeMode) {
+            if (!this.isHeader(col, row)) return !1;
+        } else if ("body" === this.internalProps.columnResizeMode && this.isHeader(col, row)) return !1;
+        const limit = this.colWidthsLimit[col];
+        return !(limit && limit.min && limit.max) || limit.max !== limit.min;
+    }
+    _canDragHeaderPosition(col, row) {
+        if (this.isHeader(col, row) && this.stateManeger.isSelected(col, row)) {
+            const selectRange = this.stateManeger.select.ranges[0];
+            if (this.isColumnHeader(col, row)) {
+                if (selectRange.end.row !== this.rowCount - 1) return !1;
+            } else {
+                if (!this.isRowHeader(col, row)) return !1;
+                if (selectRange.end.col !== this.colCount - 1) return !1;
+            }
+            const define = this.getHeaderDefine(col, row);
+            if (void 0 === define.dragHeader) {
+                if ("all" === this.internalProps.dragHeaderMode) return !0;
+                if ("column" === this.internalProps.dragHeaderMode) {
+                    if (this.isColumnHeader(col, row)) return !0;
+                } else if ("row" === this.internalProps.dragHeaderMode && this.isRowHeader(col, row)) return !0;
+                return !1;
+            }
+            return define.dragHeader;
+        }
+        return !1;
+    }
+    getCellIcons(col, row) {
+        let icons;
+        if (this.isHeader(col, row)) icons = this.internalProps.headerHelper.getIcons(col, row); else {
+            const cellValue = this.getCellValue(col, row), dataValue = this.getCellOriginValue(col, row), ctx = this.internalProps.context;
+            icons = this.internalProps.bodyHelper.getIcons(col, row, cellValue, dataValue, ctx);
+        }
+        return icons;
+    }
+    showDropDownMenu(col, row, dropDownMenuOptions) {
+        let menuType = "dropdown-menu";
+        dropDownMenuOptions && (menuType = Array.isArray(dropDownMenuOptions.content) ? "dropdown-menu" : "container"), 
+        "html" === this.internalProps.menu.renderMode && (this.stateManeger.menu.isShow = !0, 
+        this.internalProps.menuHandler._bindToCell(col, row, menuType, dropDownMenuOptions));
+    }
+    showTooltip(col, row, tooltipOptions) {
+        "html" === this.internalProps.tooltip.renderMode && this.internalProps.tooltipHandler._bindToCell(col, row, tooltipOptions);
+    }
+    getCellStyle(col, row) {
+        const actStyle = this._getCellStyle(col, row), theme = getStyleTheme(actStyle, this, col, row, getProp).theme, {autoWrapText: autoWrapText, lineClamp: lineClamp, textOverflow: textOverflow} = actStyle;
+        return {
+            textAlign: theme.text.textAlign,
+            textBaseline: theme.text.textBaseline,
+            bgColor: theme.group.fillColor,
+            color: theme.text.fillColor,
+            fontFamily: theme.text.fontFamily,
+            fontSize: theme.text.fontSize,
+            fontWeight: theme.text.fontWeight,
+            fontVariant: theme.text.fontVariant,
+            fontStyle: theme.text.fontStyle,
+            lineHeight: theme.text.lineHeight,
+            autoWrapText: null != autoWrapText && autoWrapText,
+            lineClamp: null != lineClamp ? lineClamp : "auto",
+            textOverflow: textOverflow,
+            borderColor: theme.group.strokeColor,
+            borderLineWidth: theme.group.lineWidth,
+            borderLineDash: theme.group.lineDash,
+            underline: theme.text.underline,
+            underlineDash: theme.text.underlineDash,
+            lineThrough: theme.text.lineThrough,
+            lineThroughDash: theme.text.lineThroughDash
+        };
+    }
+    getAllBodyCells(colMaxCount, rowMaxCount) {
+        const start_col = this.rowHeaderLevelCount, start_row = this.columnHeaderLevelCount, end_col = this.colCount - 1, end_row = this.rowCount - 1;
+        return Array(Math.min(null != rowMaxCount ? rowMaxCount : 2e3, end_row - start_row + 1, this.rowCount)).fill(0).map(((_, i) => Array(Math.min(null != colMaxCount ? colMaxCount : 2e3, end_col - start_col + 1, this.colCount)).fill(0).map(((_, j) => this.getCellInfo(j + start_col, i + start_row)))));
+    }
+    getAllCells(colMaxCount, rowMaxCount) {
+        const start_col = 0, start_row = 0, end_col = this.colCount - 1, end_row = this.rowCount - 1;
+        return Array(Math.min(null != rowMaxCount ? rowMaxCount : 2e3, end_row - start_row + 1, this.rowCount)).fill(0).map(((_, i) => Array(Math.min(null != colMaxCount ? colMaxCount : 2e3, end_col - start_col + 1, this.colCount)).fill(0).map(((_, j) => this.getCellInfo(j + start_col, i + start_row)))));
+    }
+    getAllColumnHeaderCells() {
+        const start_col = this.rowHeaderLevelCount, start_row = 0, end_col = this.colCount - 1, end_row = this.columnHeaderLevelCount - 1;
+        return Array(end_row - start_row + 1).fill(0).map(((_, i) => Array(end_col - start_col + 1).fill(0).map(((_, j) => this.getCellInfo(j + start_col, i + start_row)))));
+    }
+    getAllRowHeaderCells() {
+        const start_col = 0, start_row = this.columnHeaderLevelCount, end_col = this.rowHeaderLevelCount - 1, end_row = this.rowCount - 1;
+        return Array(end_row - start_row + 1).fill(0).map(((_, i) => Array(end_col - start_col + 1).fill(0).map(((_, j) => this.getCellInfo(j + start_col, i + start_row)))));
+    }
+    scrollToCell(cellAddr) {
+        const drawRange = this.getDrawRange();
+        if (isValid(cellAddr.col) && cellAddr.col >= this.frozenColCount) {
+            const frozenWidth = this.getFrozenColsWidth(), left = this.getColsWidth(0, cellAddr.col - 1);
+            this.scrollLeft = Math.min(left - frozenWidth, this.getAllColsWidth() - drawRange.width);
+        }
+        if (isValid(cellAddr.row) && cellAddr.row >= this.frozenRowCount) {
+            const frozenHeight = this.getFrozenRowsHeight(), top = this.getRowsHeight(0, cellAddr.row - 1);
+            this.scrollTop = Math.min(top - frozenHeight, this.getAllRowsHeight() - drawRange.height);
+        }
+        this.invalidate();
+    }
+    getCopyValue() {
+        const ranges = this.stateManeger.select.ranges;
+        let minCol = Math.min(ranges[0].start.col, ranges[0].end.col), maxCol = Math.max(ranges[0].start.col, ranges[0].end.col), minRow = Math.min(ranges[0].start.row, ranges[0].end.row), maxRow = Math.max(ranges[0].start.row, ranges[0].end.row);
+        ranges.forEach((a => {
+            minCol = Math.min(minCol, a.start.col, a.end.col), maxCol = Math.max(maxCol, a.start.col, a.end.col), 
+            minRow = Math.min(minRow, a.start.row, a.end.row), maxRow = Math.max(maxRow, a.start.row, a.end.row);
+        }));
+        const isExistDataInRow = r => {
+            let isExist = !1;
+            return ranges.forEach((range => {
+                const minRow = Math.min(range.start.row, range.end.row), maxRow = Math.max(range.start.row, range.end.row);
+                minRow <= r && maxRow >= r && (isExist = !0);
+            })), isExist;
+        }, isExistDataInCol = c => {
+            let isExist = !1;
+            return ranges.forEach((range => {
+                const minCol = Math.min(range.start.col, range.end.col), maxCol = Math.max(range.start.col, range.end.col);
+                minCol <= c && maxCol >= c && (isExist = !0);
+            })), isExist;
+        }, getRangeExistDataInCell = (c, r) => {
+            let isExistRange;
+            return ranges.forEach((range => {
+                const minRow = Math.min(range.start.row, range.end.row), maxRow = Math.max(range.start.row, range.end.row), minCol = Math.min(range.start.col, range.end.col), maxCol = Math.max(range.start.col, range.end.col);
+                minCol <= c && maxCol >= c && minRow <= r && maxRow >= r && (isExistRange = range);
+            })), isExistRange;
+        }, getCopyCellValue = (col, row, range) => {
+            const cellRange = this.getCellRange(col, row);
+            let copyStartCol = cellRange.start.col, copyStartRow = cellRange.start.row;
+            if (range) {
+                const rangeMinCol = Math.min(range.start.col, range.end.col), rangeMinRow = Math.min(range.start.row, range.end.row);
+                copyStartCol = Math.max(rangeMinCol, cellRange.start.col), copyStartRow = Math.max(rangeMinRow, cellRange.start.row);
+            }
+            if (copyStartCol !== col || copyStartRow !== row) return "";
+            return this.getCellValue(col, row);
+        };
+        let copyValue = "";
+        for (let r = minRow; r <= maxRow; r++) {
+            if (isExistDataInRow(r)) {
+                for (let c = minCol; c <= maxCol; c++) {
+                    if (isExistDataInCol(c)) {
+                        const range = getRangeExistDataInCell(c, r);
+                        if (range) {
+                            const copyCellValue = getCopyCellValue(c, r, range);
+                            if ("undefined" != typeof Promise && copyCellValue instanceof Promise) ; else {
+                                const strCellValue = `${copyCellValue}`;
+                                /^\[object .*\]$/.exec(strCellValue) || (copyValue += strCellValue);
+                            }
+                            (c < range.end.col || c < maxCol) && (copyValue += "\t");
+                        } else copyValue += "\t";
+                    }
+                }
+                copyValue += "\n";
+            }
+        }
+        return copyValue;
+    }
+    getSelectedCellInfos() {
+        const ranges = this.stateManeger.select.ranges;
+        let minCol = Math.min(ranges[0].start.col, ranges[0].end.col), maxCol = Math.max(ranges[0].start.col, ranges[0].end.col), minRow = Math.min(ranges[0].start.row, ranges[0].end.row), maxRow = Math.max(ranges[0].start.row, ranges[0].end.row);
+        ranges.forEach((a => {
+            minCol = Math.min(minCol, a.start.col, a.end.col), maxCol = Math.max(maxCol, a.start.col, a.end.col), 
+            minRow = Math.min(minRow, a.start.row, a.end.row), maxRow = Math.max(maxRow, a.start.row, a.end.row);
+        }));
+        const isExistDataInRow = r => {
+            let isExist = !1;
+            return ranges.forEach((range => {
+                const minRow = Math.min(range.start.row, range.end.row), maxRow = Math.max(range.start.row, range.end.row);
+                minRow <= r && maxRow >= r && (isExist = !0);
+            })), isExist;
+        }, isExistDataInCol = c => {
+            let isExist = !1;
+            return ranges.forEach((range => {
+                const minCol = Math.min(range.start.col, range.end.col), maxCol = Math.max(range.start.col, range.end.col);
+                minCol <= c && maxCol >= c && (isExist = !0);
+            })), isExist;
+        }, getRangeExistDataInCell = (c, r) => {
+            let isExistRange;
+            return ranges.forEach((range => {
+                const minRow = Math.min(range.start.row, range.end.row), maxRow = Math.max(range.start.row, range.end.row), minCol = Math.min(range.start.col, range.end.col), maxCol = Math.max(range.start.col, range.end.col);
+                minCol <= c && maxCol >= c && minRow <= r && maxRow >= r && (isExistRange = range);
+            })), isExistRange;
+        }, cellInfoArray = [];
+        for (let r = minRow; r <= maxRow; r++) {
+            if (isExistDataInRow(r)) {
+                const cellInfoRow = [];
+                for (let c = minCol; c <= maxCol; c++) {
+                    if (isExistDataInCol(c)) {
+                        if (getRangeExistDataInCell(c, r)) {
+                            const cellInfo = this.getCellInfo(c, r);
+                            cellInfoRow.push(cellInfo);
+                        }
+                    }
+                }
+                cellInfoArray.push(cellInfoRow);
+            }
+        }
+        return cellInfoArray;
+    }
+    measureText(text, font) {
+        return textMeasure.measureText(text, font);
+    }
+    measureTextBounds(attributes) {
+        const text = new WrapText(attributes);
+        return {
+            width: text.AABBBounds.width(),
+            height: text.AABBBounds.height()
+        };
+    }
+    getCustomRender(col, row) {
+        let customRender;
+        if ("body" !== this.getCellType(col, row)) {
+            const define = this.getHeaderDefine(col, row);
+            customRender = null == define ? void 0 : define.headerCustomRender;
+        } else {
+            const define = this.getBodyColumnDefine(col, row);
+            customRender = (null == define ? void 0 : define.customRender) || this.customRender;
+        }
+        return customRender;
+    }
+    getCustomLayout(col, row) {
+        let customLayout;
+        if ("body" !== this.getCellType(col, row)) {
+            const define = this.getHeaderDefine(col, row);
+            customLayout = null == define ? void 0 : define.headerCustomLayout;
+        } else {
+            const define = this.getBodyColumnDefine(col, row);
+            customLayout = null == define ? void 0 : define.customLayout;
+        }
+        return customLayout;
+    }
+}
+//# sourceMappingURL=BaseTable.js.map