@visactor/vtable/cjs/ts-types/base-table.d.ts

canvas table width high performance

import type { IBoundsLike, ITextSize } from '@visactor/vutils';
import type { MaybePromiseOrUndefined, ICellHeaderPaths, CellInfo, CustomCellStyle, CustomCellStyleArrangement, IDimensionInfo } from './common';
import type { TableEventListener, TableEventHandlersEventArgumentMap, TableEventHandlersReturnMap, EventListenerId, MousePointerCellEvent } from './events';
import type { MenuListItem, DropDownMenuEventInfo, DropDownMenuHighlightInfo } from './menu';
import type { CellStyle } from './style-define';
import type { ColumnIconOption } from './icon';
import type { ColumnData, ColumnDefine, ColumnsDefine, HeaderData, IndicatorData, SeriesNumberColumnData } from './list-table/layout-map/api';
export type { HeaderData } from './list-table/layout-map/api';
import type { TableTheme } from '../themes/theme';
import type { ICustomRender } from './customElement';
import type { LayoutObjectId } from './table-engine';
import type { Rect } from '../tools/Rect';
import type { Scenegraph } from '../scenegraph/scenegraph';
import type { StateManager } from '../state/state';
import type { EventManager } from '../event/event';
import type { CellAddress, CellRange, CellLocation, ColumnTypeOption, DataSourceAPI, FieldData, FieldDef, FullExtendStyle, HeaderValues, HeightModeDef, HierarchyState, IPivotTableDataConfig, IPagination, ITableThemeDefine, SortState, TableKeyboardOptions, WidthModeDef, IHeaderTreeDefine, IIndicator, StickCell, CustomMergeCell, CustomMerge, IColumnDimension, IRowDimension, TableEventOptions, IPivotChartDataConfig, IListTableDataConfig, IRowSeriesNumber, ColumnSeriesNumber, ColumnStyleOption, WidthAdaptiveModeDef, HeightAdaptiveModeDef, ColumnInfo, RowInfo, CellAddressWithBound, Placement, CustomMergeCellFunc } from '.';
import type { TooltipOptions } from './tooltip';
import type { ICustomLayout } from './customLayout';
import type { CachedDataSource, DataSource } from '../data';
import type { MenuHandler } from '../components/menu/dom/MenuHandler';
import type { PivotHeaderLayoutMap } from '../layout/pivot-header-layout';
import type { SimpleHeaderLayoutMap } from '../layout';
import type { TooltipHandler } from '../components/tooltip/TooltipHandler';
import type { BodyHelper } from '../body-helper/body-helper';
import type { HeaderHelper } from '../header-helper/header-helper';
import type { EventHandler } from '../event/EventHandler';
import type { NumberMap } from '../tools/NumberMap';
import type { FocusInput } from '../core/FouseInput';
import type { ITableLegendOption } from './component/legend';
import type { DataSet } from '@visactor/vdataset';
import type { Title } from '../components/title/title';
import type { ITitle } from './component/title';
import type { DiscreteTableLegend } from '../components/legend/discrete-legend/discrete-legend';
import type { ContinueTableLegend } from '../components/legend/continue-legend/continue-legend';
import type { NumberRangeMap } from '../layout/row-height-map';
import type { RowSeriesNumberHelper } from '../core/row-series-number-helper';
import type { ReactCustomLayout } from '../components/react/react-custom-layout';
import type { ISortedMapItem } from '../data/DataSource';
import type { IAnimationAppear, ITableAnimationOption } from './animation/appear';
import type { IEmptyTip } from './component/empty-tip';
import type { EmptyTip } from '../components/empty-tip/empty-tip';
import type { EditManager } from '../edit/edit-manager';
import type { TableAnimationManager } from '../core/animation';
import type { CustomCellStylePlugin } from '../plugins/custom-cell-style';
export interface IBaseTableProtected {
    element: HTMLElement;
    handler: EventHandler;
    focusControl: FocusInput;
    canvas: HTMLCanvasElement;
    context: CanvasRenderingContext2D;
    rowCount: number;
    colCount: number;
    frozenColCount: number;
    unfreezeAllOnExceedsMaxWidth: boolean;
    allowFrozenColCount: number;
    frozenRowCount: number;
    rightFrozenColCount: number;
    bottomFrozenRowCount: number;
    defaultRowHeight: number | 'auto';
    defaultHeaderRowHeight: (number | 'auto') | (number | 'auto')[];
    defaultColWidth: number;
    defaultHeaderColWidth: (number | 'auto') | (number | 'auto')[];
    keyboardOptions?: TableKeyboardOptions;
    eventOptions?: TableEventOptions;
    rowSeriesNumber?: IRowSeriesNumber;
    columnSeriesNumber?: ColumnSeriesNumber[];
    columnResizeMode?: 'all' | 'none' | 'header' | 'body';
    rowResizeMode?: 'all' | 'none' | 'header' | 'body';
    columnResizeType?: 'column' | 'indicator' | 'all' | 'indicatorGroup';
    rowResizeType?: 'row' | 'indicator' | 'all' | 'indicatorGroup';
    dragHeaderMode?: 'all' | 'none' | 'column' | 'row';
    frozenColDragHeaderMode?: 'disabled' | 'adjustFrozenCount' | 'fixedFrozenCount';
    cachedRecordsRowHeightMap: NumberMap<string | number>;
    _rowHeightsMap: NumberRangeMap;
    _colWidthsMap: NumberMap<string | number>;
    _colContentWidthsMap: NumberMap<string | number>;
    _colWidthsLimit: {
        [col: number]: {
            max?: string | number;
            min?: string | number;
        };
    };
    calcWidthContext: {
        _: IBaseTableProtected;
        full: number;
    };
    _rowRangeHeightsMap: Map<string, number>;
    _colRangeWidthsMap: Map<string, number>;
    _widthResizedColMap: Set<number | string>;
    _heightResizedRowMap: Set<number>;
    bodyHelper: BodyHelper;
    headerHelper: HeaderHelper;
    rowSeriesNumberHelper: RowSeriesNumberHelper;
    cellTextOverflows: {
        [at: string]: string;
    };
    focusedTable: boolean;
    releaseList?: {
        release: () => void;
    }[] | null;
    theme: TableTheme;
    transpose?: boolean;
    pixelRatio?: number;
    menu: {
        renderMode?: 'canvas' | 'html';
        defaultHeaderMenuItems?: MenuListItem[] | ((args: {
            row: number;
            col: number;
            table: BaseTableAPI;
        }) => MenuListItem[]);
        contextMenuItems?: MenuListItem[] | ((field: FieldDef, row: number, col: number, table?: BaseTableAPI) => MenuListItem[]);
        dropDownMenuHighlight?: DropDownMenuHighlightInfo[];
        parentElement?: HTMLElement;
    };
    tooltip: {
        parentElement: HTMLElement;
        renderMode: 'html' | 'canvas';
        isShowOverflowTextTooltip: boolean | ((col: number, row: number, table: BaseTableAPI) => boolean);
        overflowTextTooltipDisappearDelay?: number;
        confine: boolean;
        position: Placement;
    };
    dataSourceEventIds?: EventListenerId[];
    layoutMap: SimpleHeaderLayoutMap | PivotHeaderLayoutMap;
    headerValues?: HeaderValues;
    tooltipHandler: TooltipHandler;
    sortState: SortState | SortState[];
    multipleSort?: boolean;
    dataSource: DataSource | CachedDataSource;
    records?: any;
    allowRangePaste: boolean;
    autoWrapText?: boolean;
    enableLineBreak?: boolean;
    menuHandler: MenuHandler;
    limitMaxAutoWidth?: boolean | number;
    limitMinWidth?: number;
    limitMinHeight?: number;
    title?: Title;
    legends?: (DiscreteTableLegend | ContinueTableLegend)[];
    emptyTip?: EmptyTip;
    renderChartAsync?: boolean;
    stick: {
        changedCells: Map<string, StickCell>;
    };
    customMergeCell?: CustomMergeCellFunc;
    overscrollBehavior?: 'auto' | 'none';
    modifiedViewBoxTransform?: boolean;
    bodyDomContainer?: HTMLElement;
    headerDomContainer?: HTMLElement;
    frozenBodyDomContainer?: HTMLElement;
    frozenHeaderDomContainer?: HTMLElement;
    rightFrozenBodyDomContainer?: HTMLElement;
    rightFrozenHeaderDomContainer?: HTMLElement;
    frozenBottomDomContainer?: HTMLElement;
    bottomDomContainer?: HTMLElement;
    rightFrozenBottomDomContainer?: HTMLElement;
    useOneRowHeightFillAll?: boolean;
    enableTreeNodeMerge?: boolean;
    _oldRowCount?: number;
    _oldColCount?: number;
}
export interface BaseTableConstructorOptions {
    frozenColCount?: number;
    frozenRowCount?: number;
    rightFrozenColCount?: number;
    bottomFrozenRowCount?: number;
    maxFrozenWidth?: number | string;
    unfreezeAllOnExceedsMaxWidth?: boolean;
    allowFrozenColCount?: number;
    defaultRowHeight?: number | 'auto';
    defaultHeaderRowHeight?: (number | 'auto') | (number | 'auto')[];
    defaultColWidth?: number;
    defaultHeaderColWidth?: (number | 'auto') | (number | 'auto')[];
    keyboardOptions?: TableKeyboardOptions;
    excelOptions?: {
        fillHandle?: boolean | ((args: {
            selectRanges: CellRange[];
            table: BaseTableAPI;
        }) => boolean);
    };
    eventOptions?: TableEventOptions;
    container?: HTMLElement | null;
    columnResizeMode?: 'all' | 'none' | 'header' | 'body';
    rowResizeMode?: 'all' | 'none' | 'header' | 'body';
    dragHeaderMode?: 'all' | 'none' | 'column' | 'row';
    showFrozenIcon?: boolean;
    padding?: {
        top?: number;
        bottom?: number;
        left?: number;
        right?: number;
    } | number;
    hover?: {
        highlightMode?: 'cross' | 'column' | 'row' | 'cell';
        disableHover?: boolean;
        disableHeaderHover?: boolean;
        disableAxisHover?: boolean;
    };
    select?: {
        highlightMode?: 'cross' | 'column' | 'row' | 'cell';
        headerSelectMode?: 'inline' | 'cell' | 'body';
        disableSelect?: boolean | ((col: number, row: number, table: BaseTableAPI) => boolean);
        disableHeaderSelect?: boolean;
        blankAreaClickDeselect?: boolean;
        outsideClickDeselect?: boolean;
        disableDragSelect?: boolean;
        highlightInRange?: boolean;
        makeSelectCellVisible?: boolean;
    };
    menu?: {
        renderMode?: 'canvas' | 'html';
        defaultHeaderMenuItems?: MenuListItem[] | ((args: {
            row: number;
            col: number;
            table: BaseTableAPI;
        }) => MenuListItem[]);
        contextMenuItems?: MenuListItem[] | ((field: string, row: number, col: number, table?: BaseTableAPI) => MenuListItem[]);
        dropDownMenuHighlight?: DropDownMenuHighlightInfo[];
        parentElement?: HTMLElement;
    };
    tooltip?: {
        parentElement?: HTMLElement;
        renderMode?: 'html';
        isShowOverflowTextTooltip?: boolean | ((col: number, row: number, table: BaseTableAPI) => boolean);
        overflowTextTooltipDisappearDelay?: number;
        confine?: boolean;
        position?: Placement;
    };
    theme?: ITableThemeDefine;
    widthMode?: 'standard' | 'adaptive' | 'autoWidth';
    heightMode?: 'standard' | 'adaptive' | 'autoHeight';
    autoFillWidth?: boolean;
    autoFillHeight?: boolean;
    widthAdaptiveMode?: WidthAdaptiveModeDef;
    heightAdaptiveMode?: HeightAdaptiveModeDef;
    autoHeightInAdaptiveMode?: boolean;
    pixelRatio?: number;
    customRender?: ICustomRender;
    autoWrapText?: boolean;
    enableLineBreak?: boolean;
    maxCharactersNumber?: number;
    maxOperatableRecordCount?: number;
    limitMaxAutoWidth?: boolean | number;
    limitMinWidth?: boolean | number;
    limitMinHeight?: boolean | number;
    maintainedDataCount?: number;
    maintainedColumnCount?: number;
    legends?: ITableLegendOption | ITableLegendOption[];
    title?: ITitle;
    emptyTip?: true | IEmptyTip;
    renderChartAsync?: boolean;
    renderChartAsyncBatchCount?: number;
    customMergeCell?: CustomMergeCell;
    mode?: 'node' | 'browser';
    modeParams?: any;
    canvasWidth?: number | 'auto';
    canvasHeight?: number | 'auto';
    maxCanvasWidth?: number;
    maxCanvasHeight?: number;
    overscrollBehavior?: 'auto' | 'none';
    resizeTime?: number;
    canvas?: HTMLCanvasElement;
    viewBox?: IBoundsLike;
    chartOption?: any;
    disableInteraction?: boolean;
    specFormat?: (spec: any, chartInstance: any, chart: any) => {
        needFormatSpec: boolean;
        spec?: any;
        updateSpec?: boolean;
    };
    specTransformInCell?: (spec: any, col: number, row: number) => any;
    beforeRender?: (stage: any) => void;
    afterRender?: (stage: any) => void;
    rowSeriesNumber?: IRowSeriesNumber;
    customCellStyle?: CustomCellStyle[];
    customCellStyleArrangement?: CustomCellStyleArrangement[];
    columnWidthComputeMode?: 'normal' | 'only-header' | 'only-body';
    clearDOM?: boolean;
    customConfig?: {
        multilinesForXTable?: boolean;
        enableDataAnalysis?: boolean;
        _disableColumnAndRowSizeRound?: boolean;
        imageMargin?: number;
        createReactContainer?: boolean;
        shrinkSparklineFirst?: boolean;
        notUpdateInColumnRowMove?: boolean;
        limitContentHeight?: boolean;
        imageAnonymous?: boolean;
        scrollEventAlwaysTrigger?: boolean;
        enablePivotPathCache?: boolean;
    };
    animationAppear?: boolean | IAnimationAppear;
    renderOption?: any;
    formatCopyValue?: (value: string) => string;
    customComputeRowHeight?: (computeArgs: {
        row: number;
        table: BaseTableAPI;
    }) => number | 'auto' | undefined;
    tableSizeAntiJitter?: boolean;
    disableDblclickAutoResizeColWidth?: boolean;
    resize?: {
        columnResizeMode?: 'all' | 'none' | 'header' | 'body';
        rowResizeMode?: 'all' | 'none' | 'header' | 'body';
        disableDblclickAutoResizeColWidth?: boolean;
    };
    dragOrder?: {
        dragHeaderMode?: 'all' | 'none' | 'column' | 'row';
        validateDragOrderOnEnd?: (source: CellAddress, target: CellAddress) => boolean;
    };
}
export interface BaseTableAPI {
    id: string;
    recordsCount: number;
    rowCount: number;
    colCount: number;
    tableNoFrameWidth: number;
    tableNoFrameHeight: number;
    frozenRowCount: number;
    frozenColCount: number;
    bottomFrozenRowCount: number;
    rightFrozenColCount: number;
    defaultHeaderRowHeight: (number | 'auto') | (number | 'auto')[];
    defaultRowHeight: number;
    defaultColWidth: number;
    defaultHeaderColWidth: (number | 'auto') | (number | 'auto')[];
    keyboardOptions: TableKeyboardOptions | null;
    eventOptions: TableEventOptions | null;
    showFrozenIcon: boolean;
    readonly canvas: HTMLCanvasElement;
    readonly visibleRowCount: number;
    readonly visibleColCount: number;
    scrollLeft: number;
    scrollTop: number;
    options: BaseTableConstructorOptions;
    globalDropDownMenu?: MenuListItem[] | ((args: {
        row: number;
        col: number;
        table: BaseTableAPI;
    }) => MenuListItem[]);
    customRender?: ICustomRender;
    dataSource: DataSourceAPI;
    theme: TableTheme;
    allowFrozenColCount: number;
    internalProps: IBaseTableProtected;
    pagination?: IPagination;
    tableX: number;
    tableY: number;
    widthMode: WidthModeDef;
    heightMode: HeightModeDef;
    autoFillWidth: boolean;
    autoFillHeight?: boolean;
    widthAdaptiveMode: WidthAdaptiveModeDef;
    heightAdaptiveMode: HeightAdaptiveModeDef;
    isReleased: boolean;
    rowHeightsMap: NumberRangeMap;
    colWidthsMap: NumberMap<string | number>;
    on: <TYPE extends keyof TableEventHandlersEventArgumentMap>(type: TYPE, listener: TableEventListener<TYPE>) => EventListenerId;
    _vDataSet?: DataSet;
    scenegraph: Scenegraph;
    stateManager: StateManager;
    eventManager: EventManager;
    animationManager: TableAnimationManager;
    editorManager: EditManager;
    rowHeaderLevelCount: number;
    columnHeaderLevelCount: number;
    canvasWidth?: number;
    canvasHeight?: number;
    columnWidthComputeMode?: 'normal' | 'only-header' | 'only-body';
    _rowRangeHeightsMap: Map<string, number>;
    _colRangeWidthsMap: Map<string, number>;
    canvasSizeSeted?: boolean;
    pixelRatio: number;
    getDrawRange: () => Rect;
    _getMouseAbstractPoint: (evt: TouchEvent | MouseEvent | undefined, isAddScroll?: boolean) => {
        x: number;
        y: number;
        inTable: boolean;
    };
    getElement: () => HTMLElement;
    getContainer: () => HTMLElement;
    setFrozenColCount: (count: number) => void;
    _setFrozenColCount: (count: number) => void;
    _updateSize: () => void;
    render: () => void;
    throttleInvalidate: () => void;
    getRowHeight: (row: number) => number;
    getDefaultRowHeight: (row: number) => number | 'auto';
    getDefaultColumnWidth: (col: number) => number | 'auto';
    _setRowHeight: (row: number, height: number, clearCache?: boolean) => void;
    setRowHeight: (row: number, height: number) => void;
    getColWidth: (col: number) => number;
    getColWidthDefined: (col: number) => string | number;
    getColWidthDefinedNumber: (col: number) => number;
    _setColWidth: (col: number, width: number | string, clearCache?: boolean, skipCheckFrozen?: boolean) => void;
    setColWidth: (col: number, width: number) => void;
    _getColContentWidth: (col: number) => number;
    _setColContentWidth: (col: number, width: number | string, clearCache?: boolean) => void;
    getMaxColWidth: (col: number) => number;
    setMaxColWidth: (col: number, maxwidth: string | number) => void;
    getMinColWidth: (col: number) => number;
    setMinColWidth: (col: number, minwidth: string | number) => void;
    getCellRect: (col: number, row: number) => Rect;
    getCellRelativeRect: (col: number, row: number) => Rect;
    getCellsRect: (startCol: number, startRow: number, endCol: number, endRow: number) => Rect;
    getCellRangeRect: (cellRange: CellRange | CellAddress) => Rect;
    getCellRangeRelativeRect: (cellRange: CellRange | CellAddress) => Rect;
    getVisibleCellRangeRelativeRect: (cellRange: CellRange | CellAddress) => Rect;
    isFrozenCell: (col: number, row: number) => {
        row: boolean;
        col: boolean;
    } | null;
    getRowAt: (absoluteY: number) => {
        top: number;
        row: number;
        bottom: number;
    };
    getColAt: (absoluteX: number) => {
        left: number;
        col: number;
        right: number;
    };
    getCellAt: (absoluteX: number, absoluteY: number) => CellAddressWithBound;
    getCellAtRelativePosition: (absoluteX: number, absoluteY: number) => CellAddressWithBound;
    _makeVisibleCell: (col: number, row: number) => void;
    getCellOverflowText: (col: number, row: number) => string | null;
    getColsWidth: (startCol: number, endCol: number) => number;
    getRowsHeight: (startRow: number, endRow: number) => number;
    release: () => void;
    addReleaseObj: (releaseObj: {
        release: () => void;
    }) => void;
    _getCellStyle: (col: number, row: number) => FullExtendStyle;
    clearCellStyleCache: () => void;
    getFrozenRowsHeight: () => number;
    getFrozenColsWidth: () => number;
    getBottomFrozenRowsHeight: () => number;
    getRightFrozenColsWidth: () => number;
    selectCell: (col: number, row: number, isShift?: boolean, isCtrl?: boolean, makeSelectCellVisible?: boolean, skipBodyMerge?: boolean) => void;
    selectCells: (cellRanges: CellRange[]) => void;
    getAllRowsHeight: () => number;
    getAllColsWidth: () => number;
    off: (id: EventListenerId) => void;
    getBodyField: (col: number, row: number) => FieldDef | undefined;
    getRecordByCell: (col: number, row: number) => MaybePromiseOrUndefined;
    getTableIndexByRecordIndex: (recordIndex: number) => number;
    getTableIndexByField: (field: FieldDef) => number;
    getCellAddrByFieldRecord: (field: FieldDef, recordIndex: number) => CellAddress;
    getRecordShowIndexByCell: (col: number, row: number) => number;
    getRecordStartRowByRecordIndex: (index: number) => number;
    getHeaderField: (col: number, row: number) => any | undefined;
    _getHeaderCellBySortState: (sortState: SortState) => CellAddress | undefined;
    getHeaderDefine: (col: number, row: number) => ColumnDefine | IRowSeriesNumber | ColumnSeriesNumber;
    _getHeaderLayoutMap: (col: number, row: number) => HeaderData | SeriesNumberColumnData;
    getContext: () => CanvasRenderingContext2D;
    getCellRange: (col: number, row: number) => CellRange;
    _resetFrozenColCount: () => void;
    isCellRangeEqual: (col: number, row: number, targetCol: number, targetRow: number) => boolean;
    _getLayoutCellId: (col: number, row: number) => LayoutObjectId;
    _getBodyLayoutMap: (col: number, row: number) => ColumnData | IndicatorData | SeriesNumberColumnData;
    getBodyColumnDefine: (col: number, row: number) => ColumnDefine | IRowSeriesNumber | ColumnSeriesNumber;
    getBodyColumnType: (col: number, row: number) => ColumnTypeOption;
    getCellType: (col: number, row: number) => ColumnTypeOption;
    fireListeners: <TYPE extends keyof TableEventHandlersEventArgumentMap>(type: TYPE, event: TableEventHandlersEventArgumentMap[TYPE]) => TableEventHandlersReturnMap[TYPE][];
    updatePagination: (cof: IPagination) => void;
    getHeaderDescription: (col: number, row: number) => string | undefined;
    getCellValue: (col: number, row: number, skipCustomMerge?: boolean) => string | null;
    getCellOriginValue: (col: number, row: number) => any;
    getCellRawValue: (col: number, row: number) => FieldData;
    getCellOriginRecord: (col: number, row: number) => MaybePromiseOrUndefined;
    getCellRawRecord: (col: number, row: number) => MaybePromiseOrUndefined;
    _dropDownMenuIsHighlight: (col: number, row: number, index: number) => boolean;
    refreshRowColCount: () => void;
    _hasField: (field: FieldDef, col: number, row: number) => boolean;
    getCellHeaderPaths: (col: number, row: number) => ICellHeaderPaths;
    getCellLocation: (col: number, row: number) => CellLocation;
    getCellIcons: (col: number, row: number) => ColumnIconOption[];
    getMenuInfo: (col: number, row: number, type: string) => DropDownMenuEventInfo;
    getCellStyle: (col: number, row: number) => CellStyle;
    getHierarchyState: (col: number, row: number) => HierarchyState | null;
    _canDragHeaderPosition: (col: number, row: number) => boolean;
    isHeader: (col: number, row: number) => boolean;
    isColumnHeader: (col: number, row: number) => boolean;
    isCornerHeader: (col: number, row: number) => boolean;
    isRowHeader: (col: number, row: number) => boolean;
    getCopyValue: () => string;
    getSelectedCellInfos: () => CellInfo[][];
    getSelectedCellRanges: () => CellRange[];
    getCellInfo: (col: number, row: number) => Omit<MousePointerCellEvent, 'target'>;
    showTooltip: (col: number, row: number, tooltipOptions?: TooltipOptions) => void;
    measureText: (text: string, font: {
        fontSize: number;
        fontWeight?: string | number;
        fontFamily: string;
    }) => ITextSize;
    _canResizeColumn: (col: number, row: number) => boolean;
    _canResizeRow: (col: number, row: number) => boolean;
    getCustomRender: (col: number, row: number) => ICustomRender;
    getCustomLayout: (col: number, row: number) => ICustomLayout;
    isListTable: () => boolean;
    isPivotTable: (() => boolean) & (() => boolean);
    isPivotChart: (() => boolean) & (() => boolean);
    _clearColRangeWidthsMap: (col?: number) => void;
    _clearRowRangeHeightsMap: (row?: number) => void;
    clearRowHeightCache: () => void;
    clearColWidthCache: () => void;
    toggleHierarchyState: (col: number, row: number) => void;
    resize: () => void;
    setCanvasSize: (width: number, height: number) => void;
    getMergeCellRect: (col: number, row: number) => Rect;
    getTargetColAt: (absoluteX: number) => ColumnInfo | null;
    getTargetRowAt: (absoluteY: number) => RowInfo | null;
    getTargetColAtConsiderRightFrozen: (absoluteX: number, isConsider: boolean) => ColumnInfo | null;
    getTargetRowAtConsiderBottomFrozen: (absoluteY: number, isConsider: boolean) => RowInfo | null;
    renderWithRecreateCells: () => void;
    _adjustColWidth: (col: number, orgWidth: number) => number;
    _colWidthDefineToPxWidth: (width: string | number) => number;
    isFrozenColumn: (col: number, row?: number) => boolean;
    isLeftFrozenColumn: (col: number, row?: number) => boolean;
    isRightFrozenColumn: (col: number, row?: number) => boolean;
    isFrozenRow: (col: number, row?: number) => boolean;
    isTopFrozenRow: (col: number, row?: number) => boolean;
    isBottomFrozenRow: (col: number, row?: number) => boolean;
    hasCustomMerge: () => boolean;
    getCustomMerge: (col: number, row: number) => undefined | (Omit<CustomMerge, 'style'> & {
        style?: FullExtendStyle;
    });
    getBodyVisibleCellRange: () => {
        rowStart: number;
        colStart: number;
        rowEnd: number;
        colEnd: number;
    };
    getBodyVisibleColRange: () => {
        colStart: number;
        colEnd: number;
    };
    getBodyVisibleRowRange: () => {
        rowStart: number;
        rowEnd: number;
    };
    _hasCustomRenderOrLayout: () => boolean;
    getBodyIndexByTableIndex: (col: number, row: number) => CellAddress;
    getTableIndexByBodyIndex: (col: number, row: number) => CellAddress;
    scrollToCell: (cellAddr: {
        col?: number;
        row?: number;
    }, animationOption?: ITableAnimationOption | boolean) => void;
    scrollToRow: (row: number, animationOption?: ITableAnimationOption | boolean) => void;
    scrollToCol: (col: number, animationOption?: ITableAnimationOption | boolean) => void;
    registerCustomCellStyle: (customStyleId: string, customStyle: ColumnStyleOption | undefined | null) => void;
    arrangeCustomCellStyle: (cellPos: {
        col?: number;
        row?: number;
        range?: CellRange;
    }, customStyleId: string) => void;
    checkHasColumnAutoWidth: () => boolean;
    _moveHeaderPosition: (source: CellAddress, target: CellAddress) => {
        sourceIndex: number;
        targetIndex: any;
        sourceSize: any;
        targetSize: any;
        moveType: 'column' | 'row';
    };
    changeRecordOrder: (source: number, target: number) => void;
    isSeriesNumber: (col: number, row?: number) => boolean;
    isHasSeriesNumber: () => boolean;
    leftRowSeriesNumberCount: number;
    isAutoRowHeight: (row?: number) => boolean;
    reactCustomLayout?: ReactCustomLayout;
    checkReactCustomLayout: (removeAllContainer: () => void) => void;
    setSortedIndexMap: (field: FieldDef, filedMap: ISortedMapItem) => void;
    exportImg: () => string;
    exportCellImg: (col: number, row: number, options?: {
        disableBackground?: boolean;
        disableBorder?: boolean;
    }) => string;
    exportCellRangeImg: (cellRange: CellRange) => string;
    exportCanvas: () => HTMLCanvasElement;
    setPixelRatio: (pixelRatio: number) => void;
    bodyDomContainer?: HTMLElement;
    headerDomContainer?: HTMLElement;
    frozenBodyDomContainer?: HTMLElement;
    frozenHeaderDomContainer?: HTMLElement;
    rightFrozenBodyDomContainer?: HTMLElement;
    rightFrozenHeaderDomContainer?: HTMLElement;
    frozenBottomDomContainer?: HTMLElement;
    bottomDomContainer?: HTMLElement;
    rightFrozenBottomDomContainer?: HTMLElement;
    showMoverLine: (col: number, row: number) => void;
    hideMoverLine: (col: number, row: number) => void;
    disableScroll: () => void;
    enableScroll: () => void;
    customCellStylePlugin?: CustomCellStylePlugin;
    headerStyleCache: Map<string, any>;
    bodyBottomStyleCache: Map<string, any>;
    bodyStyleCache: Map<string, any>;
    bodyMergeTitleCache: Map<string, any>;
    isSeriesNumberInBody: (col: number, row: number) => boolean;
    getGroupTitleLevel: (col: number, row: number) => number | undefined;
    _getMaxFrozenWidth: () => number;
    _getComputedFrozenColCount: (frozenColCount: number) => number;
}
export interface ListTableProtected extends IBaseTableProtected {
    records: any[] | null;
    dataConfig?: IListTableDataConfig;
    columns: ColumnsDefine;
    layoutMap: SimpleHeaderLayoutMap;
    columnWidthConfig?: {
        key: string;
        width: number;
    }[];
}
export interface PivotTableProtected extends IBaseTableProtected {
    records: any[] | undefined;
    recordsIsTwoDimensionalArray?: boolean;
    layoutMap: PivotHeaderLayoutMap;
    dataConfig?: IPivotTableDataConfig;
    columnTree?: IHeaderTreeDefine[];
    rowTree?: IHeaderTreeDefine[];
    rows?: (IRowDimension | string)[];
    columns?: (IColumnDimension | string)[];
    indicators?: (IIndicator | string)[];
    columnWidthConfig?: {
        dimensions: IDimensionInfo[];
        width: number;
    }[];
    columnWidthConfigForRowHeader?: {
        dimensions: IDimensionInfo[];
        width: number;
    }[];
}
export interface PivotChartProtected extends IBaseTableProtected {
    records: any[] | Record<string, any[]>;
    layoutMap: PivotHeaderLayoutMap;
    dataConfig?: IPivotChartDataConfig;
    columnTree?: IHeaderTreeDefine[];
    rowTree?: IHeaderTreeDefine[];
    rows?: (IRowDimension | string)[];
    columns?: (IColumnDimension | string)[];
    indicators?: (IIndicator | string)[];
}