@visactor/vtable 1.6.0-alpha.1 → 1.6.0-alpha.3

package/es/layout/row-height-map.js

@@ -163,5 +163,4 @@ function indexFirst(arr, elm) {
         arr[i] > elm ? high = i - 1 : low = i + 1;
     }
     return high < 0 ? 0 : high;
-}
-//# sourceMappingURL=row-height-map.js.map
+}

package/es/layout/simple-header-layout.d.ts

@@ -29,7 +29,7 @@ export declare class SimpleHeaderLayoutMap implements LayoutMapAPI {
     _hasAggregationOnTopCount: number;
     _hasAggregationOnBottomCount: number;
     rowHierarchyType?: 'grid' | 'tree';
-    _cellRangeMap: Map<string, CellRange>;
+    private _cellRangeMap;
     constructor(table: ListTable, columns: ColumnsDefine, showHeader: boolean, hierarchyIndent: number);
     handleRowSeriesNumber(rowSeriesNumber: IRowSeriesNumber): void;
     get transpose(): boolean;
@@ -97,6 +97,7 @@ export declare class SimpleHeaderLayoutMap implements LayoutMapAPI {
     getBody(col: number, _row: number): ColumnData | SeriesNumberColumnData;
     getBodyLayoutRangeById(id: LayoutObjectId): CellRange;
     getCellRange(col: number, row: number): CellRange;
+    private getCellRangeTranspose;
     isCellRangeEqual(col: number, row: number, targetCol: number, targetRow: number): boolean;
     getRecordShowIndexByCell(col: number, row: number): number;
     getRecordStartRowByRecordIndex(index: number): number;

package/es/layout/simple-header-layout.js

@@ -8,8 +8,6 @@ import { checkHasAggregation, checkHasAggregationOnBottom, checkHasAggregationOn
 
 import { DimensionTree } from "./tree-helper";
 
-import { getCellRange } from "./cell-range/simple-cell-range";
-
 export class SimpleHeaderLayoutMap {
     constructor(table, columns, showHeader, hierarchyIndent) {
         this.seqId = 0, this.leftRowSeriesNumberColumnCount = 0, this.rightRowSeriesNumberColumnCount = 0, 
@@ -483,7 +481,93 @@ export class SimpleHeaderLayoutMap {
         throw new Error(`can not found body layout @id=${id}`);
     }
     getCellRange(col, row) {
-        return getCellRange(col, row, this);
+        var _a, _b, _c;
+        if (-1 === col || -1 === row) return {
+            start: {
+                col: col,
+                row: row
+            },
+            end: {
+                col: col,
+                row: row
+            }
+        };
+        if (this._cellRangeMap.has(`$${col}$${row}`)) return this._cellRangeMap.get(`$${col}$${row}`);
+        let cellRange = {
+            start: {
+                col: col,
+                row: row
+            },
+            end: {
+                col: col,
+                row: row
+            }
+        };
+        if (this.transpose) cellRange = this.getCellRangeTranspose(col, row); else if (this.headerLevelCount <= row) {
+            if (this.headerLevelCount <= row && (null === (_b = null === (_a = this.columnObjects[col - this.leftRowSeriesNumberColumnCount]) || void 0 === _a ? void 0 : _a.define) || void 0 === _b ? void 0 : _b.mergeCell)) {
+                const value = this._table.getCellValue(col, row);
+                for (let r = row - 1; r >= this.headerLevelCount; r--) {
+                    const last_Value = this._table.getCellValue(col, r);
+                    if ("boolean" == typeof this.columnObjects[col - this.leftRowSeriesNumberColumnCount].define.mergeCell) {
+                        if (value !== last_Value) break;
+                    } else if (!this.columnObjects[col - this.leftRowSeriesNumberColumnCount].define.mergeCell(value, last_Value)) break;
+                    cellRange.start.row = r;
+                }
+                for (let r = row + 1; r < this.rowCount; r++) {
+                    const next_Value = this._table.getCellValue(col, r);
+                    if ("boolean" == typeof this.columnObjects[col - this.leftRowSeriesNumberColumnCount].define.mergeCell) {
+                        if (value !== next_Value) break;
+                    } else if (!this.columnObjects[col - this.leftRowSeriesNumberColumnCount].define.mergeCell(value, next_Value)) break;
+                    cellRange.end.row = r;
+                }
+            }
+        } else {
+            const id = this.getCellId(col, row);
+            for (let c = col - 1; c >= 0 && id === this.getCellId(c, row); c--) cellRange.start.col = c;
+            for (let c = col + 1; c < (null !== (_c = this.colCount) && void 0 !== _c ? _c : 0) && id === this.getCellId(c, row); c++) cellRange.end.col = c;
+            for (let r = row - 1; r >= 0 && id === this.getCellId(col, r); r--) cellRange.start.row = r;
+            for (let r = row + 1; r < this.headerLevelCount && id === this.getCellId(col, r); r++) cellRange.end.row = r;
+        }
+        return this._cellRangeMap.set(`$${col}$${row}`, cellRange), cellRange;
+    }
+    getCellRangeTranspose(col, row) {
+        var _a, _b, _c, _d;
+        const result = {
+            start: {
+                col: col,
+                row: row
+            },
+            end: {
+                col: col,
+                row: row
+            }
+        };
+        if (this.headerLevelCount + this.leftRowSeriesNumberColumnCount <= col || -1 === col && -1 === row) {
+            if (this.headerLevelCount + this.leftRowSeriesNumberColumnCount <= col && (null === (_b = null === (_a = this.columnObjects[row]) || void 0 === _a ? void 0 : _a.define) || void 0 === _b ? void 0 : _b.mergeCell)) {
+                const value = this._table.getCellValue(col, row);
+                for (let c = col - 1; c >= this.headerLevelCount + this.leftRowSeriesNumberColumnCount; c--) {
+                    const last_Value = this._table.getCellValue(c, row);
+                    if ("boolean" == typeof this.columnObjects[row].define.mergeCell) {
+                        if (value !== last_Value) break;
+                    } else if (!this.columnObjects[row].define.mergeCell(value, last_Value)) break;
+                    result.start.col = c;
+                }
+                for (let c = col + 1; c < (null !== (_c = this.colCount) && void 0 !== _c ? _c : 0); c++) {
+                    const next_Value = this._table.getCellValue(c, row);
+                    if ("boolean" == typeof this.columnObjects[row].define.mergeCell) {
+                        if (value !== next_Value) break;
+                    } else if (!this.columnObjects[row].define.mergeCell(value, next_Value)) break;
+                    result.end.col = c;
+                }
+            }
+            return result;
+        }
+        const id = this.getCellId(col, row);
+        for (let r = row - 1; r >= 0 && id === this.getCellId(col, r); r--) result.start.row = r;
+        for (let r = row + 1; r < (null !== (_d = this.rowCount) && void 0 !== _d ? _d : 0) && id === this.getCellId(col, r); r++) result.end.row = r;
+        for (let c = col - 1; c >= 0 && id === this.getCellId(c, row); c--) result.start.col = c;
+        for (let c = col + 1; c < this.headerLevelCount + this.leftRowSeriesNumberColumnCount && id === this.getCellId(c, row); c++) result.end.col = c;
+        return result;
     }
     isCellRangeEqual(col, row, targetCol, targetRow) {
         const range1 = this.getCellRange(col, row), range2 = this.getCellRange(targetCol, targetRow);