@visactor/vtable/es/scenegraph/select/update-select-border.js

canvas table width high performance

import { getCellMergeInfo } from "../utils/get-cell-merge";

import { calculateCellRangeDistribution } from "../utils/cell-pos";

import { TABLE_EVENT_TYPE } from "../../core/TABLE_EVENT_TYPE";

export function updateAllSelectComponent(scene) {
    scene.customSelectedRangeComponents.forEach(((selectComp, key) => {
        updateComponent(selectComp, key, scene);
    })), scene.selectingRangeComponents.forEach(((selectComp, key) => {
        updateComponent(selectComp, key, scene);
    })), scene.selectedRangeComponents.forEach(((selectComp, key) => {
        updateComponent(selectComp, key, scene);
    }));
}

function updateComponent(selectComp, key, scene) {
    var _a, _b, _c, _d, _e, _f, _g, _h;
    const table = scene.table, [startColStr, startRowStr, endColStr, endRowStr] = key.split("-"), startCol = parseInt(startColStr, 10), startRow = parseInt(startRowStr, 10), endCol = parseInt(endColStr, 10), endRow = parseInt(endRowStr, 10);
    let visibleCellRange, computeRectCellRangeStartCol = startCol, computeRectCellRangeStartRow = startRow, computeRectCellRangeEndCol = endCol, computeRectCellRangeEndRow = endRow;
    switch (selectComp.role) {
      case "rowHeader":
        visibleCellRange = table.getBodyVisibleRowRange(), visibleCellRange && (computeRectCellRangeStartRow = Math.max(startRow, visibleCellRange.rowStart - 1), 
        computeRectCellRangeEndRow = Math.min(endRow, visibleCellRange.rowEnd + 1));
        break;

      case "columnHeader":
      case "bottomFrozen":
        visibleCellRange = table.getBodyVisibleCellRange(), visibleCellRange && (computeRectCellRangeStartCol = Math.max(startCol, visibleCellRange.colStart - 1), 
        computeRectCellRangeEndCol = Math.min(endCol, visibleCellRange.colEnd + 1));
        break;

      case "cornerHeader":
      case "rightTopCorner":
      case "leftBottomCorner":
      case "rightBottomCorner":
        break;

      case "rightFrozen":
        visibleCellRange = table.getBodyVisibleCellRange(), visibleCellRange && (computeRectCellRangeStartRow = Math.max(startRow, visibleCellRange.rowStart - 1), 
        computeRectCellRangeEndRow = Math.min(endRow, visibleCellRange.rowEnd + 1));
        break;

      default:
        visibleCellRange = table.getBodyVisibleCellRange(), visibleCellRange && (computeRectCellRangeStartRow = Math.max(startRow, visibleCellRange.rowStart - 1), 
        computeRectCellRangeEndRow = Math.min(endRow, visibleCellRange.rowEnd + 1), computeRectCellRangeStartCol = Math.max(startCol, visibleCellRange.colStart - 1), 
        computeRectCellRangeEndCol = Math.min(endCol, visibleCellRange.colEnd + 1));
    }
    const colsWidth = table.getColsWidth(computeRectCellRangeStartCol, computeRectCellRangeEndCol), rowsHeight = table.getRowsHeight(computeRectCellRangeStartRow, computeRectCellRangeEndRow), overlayGroup = scene.getSelectOverlayGroup(selectComp.role), offsetX = scene.tableGroup.attribute.x + (null !== (_a = overlayGroup.attribute.x) && void 0 !== _a ? _a : 0), offsetY = scene.tableGroup.attribute.y + (null !== (_b = overlayGroup.attribute.y) && void 0 !== _b ? _b : 0), firstCellBound = scene.highPerformanceGetCell(computeRectCellRangeStartCol, computeRectCellRangeStartRow).globalAABBBounds;
    if (selectComp.rect.setAttributes({
        x: firstCellBound.x1 - offsetX,
        y: firstCellBound.y1 - offsetY,
        width: colsWidth,
        height: rowsHeight,
        visible: !0
    }), table.hasListeners(TABLE_EVENT_TYPE.AFTER_UPDATE_SELECT_BORDER_HEIGHT) && table.fireListeners(TABLE_EVENT_TYPE.AFTER_UPDATE_SELECT_BORDER_HEIGHT, {
        startRow: computeRectCellRangeStartRow,
        endRow: computeRectCellRangeEndRow,
        currentHeight: rowsHeight,
        selectComp: selectComp
    }), selectComp.fillhandle) {
        const fillHandle = null === (_c = scene.table.options.excelOptions) || void 0 === _c ? void 0 : _c.fillHandle;
        let lastCellBound, handlerX, visible = !0;
        "function" == typeof fillHandle && (visible = fillHandle({
            selectRanges: scene.table.stateManager.select.ranges,
            table: scene.table
        })), endCol < table.colCount - 1 ? (lastCellBound = scene.highPerformanceGetCell(endCol, endRow).globalAABBBounds, 
        handlerX = lastCellBound.x2 - offsetX - 3) : 0 === startCol ? (lastCellBound = scene.highPerformanceGetCell(0, endRow).globalAABBBounds, 
        handlerX = lastCellBound.x1 - offsetX) : (lastCellBound = scene.highPerformanceGetCell(startCol - 1, endRow).globalAABBBounds, 
        handlerX = lastCellBound.x2 - offsetX - 3), lastCellBound = endRow < table.rowCount - 1 ? scene.highPerformanceGetCell(endCol, endRow).globalAABBBounds : scene.highPerformanceGetCell(endCol, startRow - 1).globalAABBBounds;
        const handlerY = lastCellBound.y2 - offsetY - 3;
        null === (_d = selectComp.fillhandle) || void 0 === _d || _d.setAttributes({
            x: handlerX,
            y: handlerY,
            width: 6,
            height: 6,
            visible: visible
        });
    }
    let diffSize = 0;
    "number" == typeof selectComp.rect.attribute.lineWidth && (diffSize = Math.ceil(selectComp.rect.attribute.lineWidth / 2)), 
    endCol === table.colCount - 1 && (Array.isArray(selectComp.rect.attribute.lineWidth) && (diffSize = Math.ceil((null !== (_e = selectComp.rect.attribute.lineWidth[1]) && void 0 !== _e ? _e : 0) / 2)), 
    selectComp.rect.setAttributes({
        width: selectComp.rect.attribute.width - diffSize
    })), 0 === startCol && (Array.isArray(selectComp.rect.attribute.lineWidth) && (diffSize = Math.ceil((null !== (_f = selectComp.rect.attribute.lineWidth[3]) && void 0 !== _f ? _f : 0) / 2)), 
    selectComp.rect.setAttributes({
        x: selectComp.rect.attribute.x + diffSize,
        width: selectComp.rect.attribute.width - diffSize
    })), endRow === table.rowCount - 1 && (Array.isArray(selectComp.rect.attribute.lineWidth) && (diffSize = Math.ceil((null !== (_g = selectComp.rect.attribute.lineWidth[2]) && void 0 !== _g ? _g : 0) / 2)), 
    selectComp.rect.setAttributes({
        height: selectComp.rect.attribute.height - diffSize
    })), 0 === startRow && (Array.isArray(selectComp.rect.attribute.lineWidth) && (diffSize = Math.ceil((null !== (_h = selectComp.rect.attribute.lineWidth[0]) && void 0 !== _h ? _h : 0) / 2)), 
    selectComp.rect.setAttributes({
        y: selectComp.rect.attribute.y + diffSize,
        height: selectComp.rect.attribute.height - diffSize
    }));
}

export function updateCellSelectBorder(scene, selectRange, ifExtendSelectRange = !0) {
    const table = scene.table, newStartCol = selectRange.start.col, newStartRow = selectRange.start.row, newEndCol = selectRange.end.col, newEndRow = selectRange.end.row, skipBodyMerge = selectRange.skipBodyMerge;
    let startCol = Math.max(Math.min(newEndCol, newStartCol), 0), startRow = Math.max(Math.min(newEndRow, newStartRow), 0), endCol = Math.min(Math.max(newEndCol, newStartCol), table.colCount - 1), endRow = Math.min(Math.max(newEndRow, newStartRow), table.rowCount - 1);
    const extendSelectRange = () => {
        let isExtend = !1;
        for (let col = startCol; col <= endCol; col++) {
            if (col === startCol) for (let row = startRow; row <= endRow; row++) {
                if (!table.isHeader(col, row) && skipBodyMerge) continue;
                const mergeInfo = getCellMergeInfo(table, col, row);
                if (mergeInfo && mergeInfo.start.col < startCol) {
                    startCol = mergeInfo.start.col, isExtend = !0;
                    break;
                }
            }
            if (!isExtend && col === endCol) for (let row = startRow; row <= endRow; row++) {
                if (!table.isHeader(col, row) && skipBodyMerge) continue;
                const mergeInfo = getCellMergeInfo(table, col, row);
                if (mergeInfo && Math.min(mergeInfo.end.col, table.colCount - 1) > endCol) {
                    endCol = mergeInfo.end.col, isExtend = !0;
                    break;
                }
            }
            if (isExtend) break;
        }
        if (!isExtend) for (let row = startRow; row <= endRow; row++) {
            if (row === startRow) for (let col = startCol; col <= endCol; col++) {
                if (!table.isHeader(col, row) && skipBodyMerge) continue;
                const mergeInfo = getCellMergeInfo(table, col, row);
                if (mergeInfo && mergeInfo.start.row < startRow) {
                    startRow = mergeInfo.start.row, isExtend = !0;
                    break;
                }
            }
            if (!isExtend && row === endRow) for (let col = startCol; col <= endCol; col++) {
                if (!table.isHeader(col, row) && skipBodyMerge) continue;
                const mergeInfo = getCellMergeInfo(table, col, row);
                if (mergeInfo && Math.min(mergeInfo.end.row, table.rowCount - 1) > endRow) {
                    endRow = mergeInfo.end.row, isExtend = !0;
                    break;
                }
            }
            if (isExtend) break;
        }
        isExtend && extendSelectRange();
    };
    ifExtendSelectRange && (extendSelectRange(), selectRange.start.col > selectRange.end.col ? (selectRange.start.col = Math.max(startCol, endCol), 
    selectRange.end.col = Math.min(startCol, endCol)) : (selectRange.start.col = Math.min(startCol, endCol), 
    selectRange.end.col = Math.max(startCol, endCol)), selectRange.start.row > selectRange.end.row ? (selectRange.start.row = Math.max(startRow, endRow), 
    selectRange.end.row = Math.min(startRow, endRow)) : (selectRange.start.row = Math.min(startRow, endRow), 
    selectRange.end.row = Math.max(startRow, endRow))), scene.selectingRangeComponents.forEach(((selectComp, key) => {
        var _a;
        selectComp.rect.delete(), null === (_a = selectComp.fillhandle) || void 0 === _a || _a.delete();
    })), scene.selectingRangeComponents = new Map;
    const {needRowHeader: needRowHeader, needRightRowHeader: needRightRowHeader, needColumnHeader: needColumnHeader, needBottomColumnHeader: needBottomColumnHeader, needBody: needBody, needCornerHeader: needCornerHeader, needRightTopCornerHeader: needRightTopCornerHeader, needLeftBottomCornerHeader: needLeftBottomCornerHeader, needRightBottomCornerHeader: needRightBottomCornerHeader} = calculateCellRangeDistribution(startCol, startRow, endCol, endRow, table);
    if (needCornerHeader) {
        const cornerEndCol = Math.min(endCol, table.frozenColCount - 1), cornerEndRow = Math.min(endRow, table.frozenRowCount - 1), strokeArray = [ !0, !needColumnHeader, !needRowHeader, !0 ];
        scene.createCellSelectBorder(startCol, startRow, cornerEndCol, cornerEndRow, "cornerHeader", `${startCol}${startRow}${endCol}${endRow}`, strokeArray);
    }
    if (needRightTopCornerHeader) {
        const cornerStartCol = Math.max(startCol, table.colCount - table.rightFrozenColCount), cornerEndRow = Math.min(endRow, table.frozenRowCount - 1), strokeArray = [ !0, !0, !needRightRowHeader, !needColumnHeader ];
        scene.createCellSelectBorder(cornerStartCol, startRow, endCol, cornerEndRow, "rightTopCorner", `${startCol}${startRow}${endCol}${endRow}`, strokeArray);
    }
    if (needLeftBottomCornerHeader) {
        const cornerEndCol = Math.min(endCol, table.frozenColCount - 1), cornerStartRow = Math.max(startRow, table.rowCount - table.bottomFrozenRowCount), strokeArray = [ !needRowHeader, !needBottomColumnHeader, !0, !0 ];
        scene.createCellSelectBorder(startCol, cornerStartRow, cornerEndCol, endRow, "leftBottomCorner", `${startCol}${startRow}${endCol}${endRow}`, strokeArray);
    }
    if (needRightBottomCornerHeader) {
        const cornerStartCol = Math.max(startCol, table.colCount - table.rightFrozenColCount), cornerStartRow = Math.max(startRow, table.rowCount - table.bottomFrozenRowCount), strokeArray = [ !needRightRowHeader, !0, !0, !needBottomColumnHeader ];
        scene.createCellSelectBorder(cornerStartCol, cornerStartRow, endCol, endRow, "rightBottomCorner", `${startCol}${startRow}${endCol}${endRow}`, strokeArray);
    }
    if (needColumnHeader) {
        const columnHeaderStartCol = Math.max(startCol, table.frozenColCount), columnHeaderEndCol = Math.min(endCol, table.colCount - table.rightFrozenColCount - 1), columnHeaderEndRow = Math.min(endRow, table.frozenRowCount - 1), strokeArray = [ !0, !needRightTopCornerHeader, !needBody, !needCornerHeader ];
        scene.createCellSelectBorder(columnHeaderStartCol, startRow, columnHeaderEndCol, columnHeaderEndRow, "columnHeader", `${startCol}${startRow}${endCol}${endRow}`, strokeArray);
    }
    if (needBottomColumnHeader) {
        const columnHeaderStartCol = Math.max(startCol, table.frozenColCount), columnHeaderEndCol = Math.min(endCol, table.colCount - table.rightFrozenColCount - 1), columnHeaderStartRow = Math.max(startRow, table.rowCount - table.bottomFrozenRowCount), strokeArray = [ !needBody, !needRightBottomCornerHeader, !0, !needLeftBottomCornerHeader ];
        scene.createCellSelectBorder(columnHeaderStartCol, columnHeaderStartRow, columnHeaderEndCol, endRow, "bottomFrozen", `${startCol}${startRow}${endCol}${endRow}`, strokeArray);
    }
    if (needRowHeader) {
        const columnHeaderStartRow = Math.max(startRow, table.frozenRowCount), columnHeaderEndRow = Math.min(endRow, table.rowCount - table.bottomFrozenRowCount - 1), columnHeaderEndCol = Math.min(endCol, table.frozenColCount - 1), strokeArray = [ !needCornerHeader, !needBody, !needLeftBottomCornerHeader, !0 ];
        scene.createCellSelectBorder(startCol, columnHeaderStartRow, columnHeaderEndCol, columnHeaderEndRow, "rowHeader", `${startCol}${startRow}${endCol}${endRow}`, strokeArray);
    }
    if (needRightRowHeader) {
        const columnHeaderStartRow = Math.max(startRow, table.frozenRowCount), columnHeaderEndRow = Math.min(endRow, table.rowCount - table.bottomFrozenRowCount - 1), columnHeaderStartCol = Math.max(startCol, table.colCount - table.rightFrozenColCount), strokeArray = [ !needRightTopCornerHeader, !0, !needRightBottomCornerHeader, !needBody ];
        scene.createCellSelectBorder(columnHeaderStartCol, columnHeaderStartRow, endCol, columnHeaderEndRow, "rightFrozen", `${startCol}${startRow}${endCol}${endRow}`, strokeArray);
    }
    if (needBody) {
        const columnHeaderStartCol = Math.max(startCol, table.frozenColCount), columnHeaderStartRow = Math.max(startRow, table.frozenRowCount), columnHeaderEndCol = Math.min(endCol, table.colCount - table.rightFrozenColCount - 1), columnHeaderEndRow = Math.min(endRow, table.rowCount - table.bottomFrozenRowCount - 1), strokeArray = [ !needColumnHeader, !needRightRowHeader, !needBottomColumnHeader, !needRowHeader ];
        scene.createCellSelectBorder(columnHeaderStartCol, columnHeaderStartRow, columnHeaderEndCol, columnHeaderEndRow, "body", `${startCol}${startRow}${endCol}${endRow}`, strokeArray);
    }
}

export function hideCellSelectBorder(scene) {
    scene.selectingRangeComponents.forEach(((selectComp, key) => {
        selectComp.rect.setAttribute("opacity", 0);
    })), scene.selectedRangeComponents.forEach(((selectComp, key) => {
        selectComp.rect.setAttribute("opacity", 0);
    }));
}

export function restoreCellSelectBorder(scene) {
    scene.selectingRangeComponents.forEach(((selectComp, key) => {
        selectComp.rect.setAttribute("opacity", 1);
    })), scene.selectedRangeComponents.forEach(((selectComp, key) => {
        selectComp.rect.setAttribute("opacity", 1);
    }));
}
//# sourceMappingURL=update-select-border.js.map