Skip to content

Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.

perf(sheet): add span model (#3403)

VicKunc357724305ef
diff --git a/packages/core/src/sheets/__tests__/span-mode.spec.ts b/packages/core/src/sheets/__tests__/span-mode.spec.ts
new file mode 100644
index 0000000000..79d1440a5c
--- /dev/null
+++ b/packages/core/src/sheets/__tests__/span-mode.spec.ts
@@ -0,0 +1,239 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { Rectangle } from '../../shared';
+import { SpanModel } from '../span-model';
+import { type IRange, RANGE_TYPE } from '../typedef';
+
+function getMergeRange(mergeData: IRange[], startRow: number, startColumn: number, endRow: number, endColumn: number) {
+ const ranges: IRange[] = [];
+ for (const range of mergeData || []) {
+ if (Rectangle.intersects(range, {
+ startRow,
+ endRow,
+ startColumn,
+ endColumn,
+ })) {
+ ranges.push({
+ ...range,
+ });
+ }
+ }
+ return ranges;
+}
+
+describe('test span mode', () => {
+ it('test getMergedCell', () => {
+ const ranges: IRange[] = [
+ { startRow: 1, endRow: 2, startColumn: 1, endColumn: 2 },
+ ];
+ const spanModel = new SpanModel(ranges);
+
+ const mergedCell = spanModel.getMergedCell(1, 1);
+ expect(mergedCell).toEqual({ startRow: 1, endRow: 2, startColumn: 1, endColumn: 2 });
+
+ const mergedCell2 = spanModel.getMergedCell(1, 2);
+ expect(mergedCell2).toEqual({ startRow: 1, endRow: 2, startColumn: 1, endColumn: 2 });
+
+ const mergedCell3 = spanModel.getMergedCell(2, 4);
+ expect(mergedCell3).toEqual(null);
+ });
+
+ it('test getMergedCellByRange', () => {
+ const ranges: IRange[] = [
+ { startRow: 1, endRow: 2, startColumn: 1, endColumn: 2 },
+ { startRow: 3, endRow: 4, startColumn: 3, endColumn: 4 },
+ ];
+ const spanModel = new SpanModel(ranges);
+
+ const range1 = getMergeRange(ranges, 1, 1, 2, 2);
+ const mergedCell = spanModel.getMergedCellRange(1, 1, 2, 2);
+
+ expect(mergedCell).toEqual(range1);
+ });
+
+ it('test getMergedCellByRange complex', () => {
+ const ranges: IRange[] = [
+ {
+ startRow: 0,
+ startColumn: 0,
+ endRow: 3,
+ endColumn: 2,
+ rangeType: 0,
+ },
+ {
+ startRow: 4,
+ startColumn: 3,
+ endRow: 9,
+ endColumn: 3,
+ rangeType: 0,
+ },
+ {
+ startRow: 1,
+ startColumn: 3,
+ endRow: 1,
+ endColumn: 7,
+ rangeType: 0,
+ },
+ {
+ startRow: 5,
+ startColumn: 4,
+ endRow: 13,
+ endColumn: 6,
+ rangeType: 0,
+ },
+ {
+ startRow: 1,
+ startColumn: 8,
+ endRow: 18,
+ endColumn: 8,
+ rangeType: 0,
+ },
+ {
+ startRow: 20,
+ startColumn: 0,
+ endRow: 21,
+ endColumn: 10,
+ rangeType: 0,
+ },
+ ];
+ const spanModel = new SpanModel(ranges);
+
+ const range1 = getMergeRange(ranges, 1, 1, 2, 2);
+ const mergedCell = spanModel.getMergedCellRange(1, 1, 2, 2);
+
+ expect(mergedCell).toEqual(range1);
+ });
+
+ it('test update snapshot', () => {
+ const ranges: IRange[] = [
+ {
+ startRow: 0,
+ startColumn: 0,
+ endRow: 3,
+ endColumn: 2,
+ rangeType: 0,
+ },
+ {
+ startRow: 4,
+ startColumn: 3,
+ endRow: 9,
+ endColumn: 3,
+ rangeType: 0,
+ },
+ {
+ startRow: 1,
+ startColumn: 3,
+ endRow: 1,
+ endColumn: 7,
+ rangeType: 0,
+ },
+ {
+ startRow: 5,
+ startColumn: 4,
+ endRow: 13,
+ endColumn: 6,
+ rangeType: 0,
+ },
+ {
+ startRow: 1,
+ startColumn: 8,
+ endRow: 18,
+ endColumn: 8,
+ rangeType: 0,
+ },
+ {
+ startRow: 20,
+ startColumn: 0,
+ endRow: 21,
+ endColumn: 10,
+ rangeType: 0,
+ },
+ ];
+ const spanModel = new SpanModel(ranges);
+
+ const range1 = getMergeRange(ranges, 1, 1, 2, 2);
+ const mergedCell = spanModel.getMergedCellRange(1, 1, 2, 2);
+
+ expect(mergedCell).toEqual(range1);
+
+ ranges.push({ startRow: 30, endRow: 32, startColumn: 1, endColumn: 2 });
+ spanModel.rebuild(ranges);
+
+ const range2 = getMergeRange(ranges, 30, 1, 32, 2);
+ const mergedCell2 = spanModel.getMergedCellRange(30, 1, 32, 2);
+
+ expect(mergedCell2).toEqual(range2);
+ });
+
+ it('test column range', () => {
+ const ranges: IRange[] = [
+ { startRow: 1, endRow: 2, startColumn: 1, endColumn: 2, rangeType: RANGE_TYPE.COLUMN },
+ ];
+ const spanModel = new SpanModel(ranges);
+ expect(Boolean(spanModel.getMergedCell(1, 1))).toEqual(true);
+ expect(Boolean(spanModel.getMergedCell(1, 2))).toEqual(true);
+ expect(Boolean(spanModel.getMergedCell(1, 3))).toEqual(false);
+ });
+ it('test row range', () => {
+ const ranges: IRange[] = [
+ { startRow: 1, endRow: 2, startColumn: 1, endColumn: 2, rangeType: RANGE_TYPE.ROW },
+ ];
+ const spanModel = new SpanModel(ranges);
+ expect(Boolean(spanModel.getMergedCell(1, 1))).toEqual(true);
+ expect(Boolean(spanModel.getMergedCell(2, 1))).toEqual(true);
+ expect(Boolean(spanModel.getMergedCell(3, 1))).toEqual(false);
+ });
+
+ it('test all range', () => {
+ const ranges: IRange[] = [
+ { startRow: 1, endRow: 2, startColumn: 1, endColumn: 2, rangeType: RANGE_TYPE.ALL },
+ ];
+ const spanModel = new SpanModel(ranges);
+ expect(Boolean(spanModel.getMergedCell(1, 1))).toEqual(true);
+ expect(Boolean(spanModel.getMergedCell(2, 1))).toEqual(true);
+ expect(Boolean(spanModel.getMergedCell(3, 1))).toEqual(true);
+ });
+
+ it('test isRowContainsMergedCell', () => {
+ const spanModelAll = new SpanModel([{ startRow: 1, endRow: 2, startColumn: 1, endColumn: 2, rangeType: RANGE_TYPE.ALL }]);
+ expect(Boolean(spanModelAll.isRowContainsMergedCell(1))).toEqual(true);
+ expect(Boolean(spanModelAll.isRowContainsMergedCell(2))).toEqual(true);
+ expect(Boolean(spanModelAll.isRowContainsMergedCell(3))).toEqual(true);
+
+ const spanModelRow = new SpanModel([{ startRow: 1, endRow: 1, startColumn: 1, endColumn: 2, rangeType: RANGE_TYPE.COLUMN }]);
+ expect(Boolean(spanModelRow.isRowContainsMergedCell(1))).toEqual(true);
+
+ const spanModelCell = new SpanModel([{ startRow: 1, endRow: 2, startColumn: 1, endColumn: 2, rangeType: RANGE_TYPE.NORMAL }]);
+ expect(Boolean(spanModelCell.isRowContainsMergedCell(1))).toEqual(true);
+ expect(Boolean(spanModelCell.isRowContainsMergedCell(2))).toEqual(true);
+ expect(Boolean(spanModelCell.isRowContainsMergedCell(3))).toEqual(false);
+ });
+
+ it('test isColumnContainsMergedCell', () => {
+ const spanModelAll = new SpanModel([{ startRow: 1, endRow: 2, startColumn: 1, endColumn: 2, rangeType: RANGE_TYPE.ALL }]);
+ expect(Boolean(spanModelAll.isColumnContainsMergedCell(1))).toEqual(true);
+ expect(Boolean(spanModelAll.isColumnContainsMergedCell(2))).toEqual(true);
+ expect(Boolean(spanModelAll.isColumnContainsMergedCell(3))).toEqual(true);
+
+ const spanModelRow = new SpanModel([{ startRow: 1, endRow: 2, startColumn: 1, endColumn: 1, rangeType: RANGE_TYPE.ROW }]);
+ expect(Boolean(spanModelRow.isColumnContainsMergedCell(1))).toEqual(true);
+
+ const spanModelCell = new SpanModel([{ startRow: 1, endRow: 2, startColumn: 1, endColumn: 2, rangeType: RANGE_TYPE.NORMAL }]);
+ expect(Boolean(spanModelCell.isColumnContainsMergedCell(1))).toEqual(true);
+ });
+});
diff --git a/packages/core/src/sheets/span-model.ts b/packages/core/src/sheets/span-model.ts
new file mode 100644
index 0000000000..346c9a57f2
--- /dev/null
+++ b/packages/core/src/sheets/span-model.ts
@@ -0,0 +1,292 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { LRUMap, Rectangle, Tools } from '../shared';
+import { Disposable } from '../shared/lifecycle';
+import { RANGE_TYPE } from './typedef';
+import type { IRange } from './typedef';
+
+interface IMergeDataCache {
+ [key: string]: number;
+}
+export class SpanModel extends Disposable {
+ /**
+ * @property Cache for RANGE_TYPE.NORMAL
+ */
+ private _cellCache: IMergeDataCache = {};
+ /**
+ * @property Cache for RANGE_TYPE.ROW
+ */
+ private _rowCache: IMergeDataCache = {};
+ /**
+ * @property Cache for RANGE_TYPE.COLUMN
+ */
+ private _columnCache: IMergeDataCache = {};
+ /**
+ * @property Whether has RANGE_TYPE.ALL
+ */
+ private _hasAll: boolean = false;
+ /**
+ * @property Index for RANGE_TYPE.ALL
+ */
+ private _allIndex: number = -1;
+
+ /**
+ * @property the original merge data
+ */
+ private _mergeData: IRange[];
+
+ private _rangeMap: LRUMap<string, number[]> = new LRUMap<string, number[]>(50000);
+
+ private _skeletonCache: LRUMap<string, number[]> = new LRUMap<string, number[]>(50000); ;
+
+ constructor(mergeData: IRange[]) {
+ super();
+ this._init(mergeData.concat());
+ }
+
+ private _init(mergeData: IRange[]) {
+ this._mergeData = mergeData;
+ this._createCache(mergeData);
+ }
+
+ private _clearCache() {
+ this._cellCache = {};
+ this._rowCache = {};
+ this._columnCache = {};
+ this._hasAll = false;
+ this._allIndex = -1;
+ this._rangeMap.clear();
+ this._skeletonCache.clear();
+ }
+
+ private _createCache(mergeData: IRange[]) {
+ let index = 0;
+ for (const range of mergeData) {
+ const { rangeType } = range;
+ if (rangeType === RANGE_TYPE.ROW) {
+ this._createRowCache(range, index);
+ } else if (rangeType === RANGE_TYPE.COLUMN) {
+ this._createColumnCache(range, index);
+ } else if (rangeType === RANGE_TYPE.ALL) {
+ this._createCellAllCache(index);
+ } else {
+ this._createCellCache(range, index);
+ }
+ index++;
+ }
+ }
+
+ /**
+ * Rebuild the merge data cache when the merge data is changed.
+ * @param {IRange[]} mergeData
+ */
+ rebuild(mergeData: IRange[]) {
+ this._clearCache();
+ this._init(mergeData.concat());
+ }
+
+ private _createRowCache(range: IRange, index: number) {
+ const { startRow, endRow } = range;
+ for (let i = startRow; i <= endRow; i++) {
+ const key = `${i}`;
+ this._rowCache[key] = index;
+ }
+ }
+
+ private _createColumnCache(range: IRange, index: number) {
+ const { startColumn, endColumn } = range;
+ for (let i = startColumn; i <= endColumn; i++) {
+ const key = `${i}`;
+ this._columnCache[key] = index;
+ }
+ }
+
+ private _createCellAllCache(index: number) {
+ this._hasAll = true;
+ this._allIndex = index;
+ }
+
+ private _createCellCache(range: IRange, index: number) {
+ for (let i = range.startRow; i <= range.endRow; i++) {
+ for (let j = range.startColumn; j <= range.endColumn; j++) {
+ this._cellCache[`${i}-${j}`] = index;
+ }
+ }
+ }
+
+ public add(range: IRange) {
+ this._mergeData.push(range);
+ this._clearCache();
+ this._createCache(this._mergeData);
+ }
+
+ public remove(row: number, column: number) {
+ const index = this._getMergeDataIndex(row, column);
+ if (index !== -1) {
+ this._mergeData.splice(index, 1);
+ this._clearCache();
+ this._createCache(this._mergeData);
+ }
+ }
+
+ public getMergedCell(row: number, column: number) {
+ const index = this._getMergeDataIndex(row, column);
+ if (index !== -1) {
+ return this._mergeData[index];
+ }
+ return null;
+ }
+
+ public isRowContainsMergedCell(row: number) {
+ if (this._hasAll) {
+ return true;
+ }
+ if (!Tools.isEmptyObject(this._columnCache)) {
+ return true;
+ }
+ return this._mergeData.some((mergedCell) => mergedCell.startRow <= row && row <= mergedCell.endRow);
+ }
+
+ public isColumnContainsMergedCell(column: number) {
+ if (this._hasAll) {
+ return true;
+ }
+ if (!Tools.isEmptyObject(this._rowCache)) {
+ return true;
+ }
+ return this._mergeData.some((mergedCell) => mergedCell.startColumn <= column && column <= mergedCell.endColumn);
+ }
+
+ public getMergedCellRange(startRow: number, startColumn: number, endRow: number, endColumn: number) {
+ const ranges: IRange[] = [];
+
+ const key = `${startRow}-${startColumn}-${endRow}-${endColumn}`;
+ if (this._rangeMap.has(key)) {
+ return this._getRangeFromCache(key);
+ }
+ let index = 0;
+ const indexes: number[] = [];
+ for (const range of this._mergeData || []) {
+ if (Rectangle.intersects(range, {
+ startRow,
+ endRow,
+ startColumn,
+ endColumn,
+ })) {
+ ranges.push({
+ ...range,
+ });
+ indexes.push(index);
+ index++;
+ }
+ }
+ this._rangeMap.set(key, indexes);
+ return ranges;
+ }
+
+ public getMergedCellRangeForSkeleton(startRow: number, startColumn: number, endRow: number, endColumn: number) {
+ // copy from packages\engine-render\src\components\sheets\sheet-skeleton.ts _getMergeCells
+ const cacheDataMerge: IRange[] = [];
+ const mergeData = this._mergeData;
+ const key = `${startRow}-${startColumn}-${endRow}-${endColumn}`;
+
+ if (this._skeletonCache.has(key)) {
+ return this._getSkeletonRangeFromCache(key);
+ }
+ const indexes: number[] = [];
+
+ for (let i = 0; i < mergeData.length; i++) {
+ const {
+ startRow: mergeStartRow,
+ endRow: mergeEndRow,
+ startColumn: mergeStartColumn,
+ endColumn: mergeEndColumn,
+ } = mergeData[i];
+ for (let r = startRow; r <= endRow; r++) {
+ let isBreak = false;
+ for (let c = startColumn; c <= endColumn; c++) {
+ if (r >= mergeStartRow && r <= mergeEndRow && c >= mergeStartColumn && c <= mergeEndColumn) {
+ cacheDataMerge.push({
+ startRow: mergeStartRow,
+ endRow: mergeEndRow,
+ startColumn: mergeStartColumn,
+ endColumn: mergeEndColumn,
+ });
+ indexes.push(i);
+ isBreak = true;
+ break;
+ }
+ }
+ if (isBreak) {
+ break;
+ }
+ }
+ }
+ this._skeletonCache.set(key, indexes);
+ return cacheDataMerge;
+ }
+
+ private _getRangeFromCache(key: string) {
+ const indexes = this._rangeMap.get(key) || [];
+ const ranges: IRange[] = [];
+ for (const index of indexes) {
+ ranges.push({
+ ...this._mergeData[index],
+ });
+ }
+ return ranges;
+ }
+
+ private _getSkeletonRangeFromCache(key: string) {
+ const indexes = this._skeletonCache.get(key) || [];
+ const ranges: IRange[] = [];
+ for (const index of indexes) {
+ ranges.push({
+ ...this._mergeData[index],
+ });
+ }
+ return ranges;
+ }
+
+ private _getMergeDataIndex(row: number, column: number) {
+ if (this._hasAll) {
+ return this._allIndex;
+ }
+ const rowKey = `${row}`;
+ const columnKey = `${column}`;
+ if (this._rowCache[rowKey] !== undefined) {
+ return this._rowCache[rowKey];
+ }
+ if (this._columnCache[columnKey] !== undefined) {
+ return this._columnCache[columnKey];
+ }
+ const key = `${row}-${column}`;
+ if (this._cellCache[key] !== undefined) {
+ return this._cellCache[key];
+ }
+ return -1;
+ }
+
+ public getMergeDataSnapshot() {
+ return this._mergeData;
+ }
+
+ override dispose() {
+ this._clearCache();
+ this._mergeData = [];
+ }
+}
diff --git a/packages/core/src/sheets/typedef.ts b/packages/core/src/sheets/typedef.ts
index 1387bdbccb..23385633ea 100644
--- a/packages/core/src/sheets/typedef.ts
+++ b/packages/core/src/sheets/typedef.ts
@@ -613,6 +613,7 @@ export interface ITextRangeParam extends ITextRange {
/**
* Determines whether the cell(row, column) is within the range of the merged cells.
+ * @deprecated please use worksheet.getCellInfoInMergeData instead
*/
export function getCellInfoInMergeData(row: number, column: number, mergeData?: IRange[]): ISelectionCell {
let isMerged = false; // The upper left cell only renders the content
diff --git a/packages/core/src/sheets/worksheet.ts b/packages/core/src/sheets/worksheet.ts
index 82bdc367b3..958398e2b2 100644
--- a/packages/core/src/sheets/worksheet.ts
+++ b/packages/core/src/sheets/worksheet.ts
@@ -15,17 +15,18 @@
*/
import { BuildTextUtils } from '../docs';
-import { ObjectMatrix, Rectangle, Tools } from '../shared';
+import { ObjectMatrix, Tools } from '../shared';
import { createRowColIter } from '../shared/row-col-iter';
import { type BooleanNumber, CellValueType } from '../types/enum';
import { ColumnManager } from './column-manager';
import { Range } from './range';
import { RowManager } from './row-manager';
import { mergeWorksheetSnapshotWithDefault } from './sheet-snapshot-utils';
+import { SpanModel } from './span-model';
import { SheetViewModel } from './view-model';
import type { IObjectMatrixPrimitiveType, Nullable } from '../shared';
import type { Styles } from './styles';
-import type { ICellData, ICellDataForSheetInterceptor, IFreeze, IRange, IWorksheetData } from './typedef';
+import type { ICellData, ICellDataForSheetInterceptor, IFreeze, IRange, ISelectionCell, IWorksheetData } from './typedef';
/**
* The model of a Worksheet.
@@ -40,6 +41,8 @@ export class Worksheet {
protected readonly _viewModel: SheetViewModel;
+ protected _spanModel: SpanModel;
+
constructor(
public readonly unitId: string,
snapshot: Partial<IWorksheetData>,
@@ -55,6 +58,7 @@ export class Worksheet {
this._viewModel = new SheetViewModel((row, col) => this.getCellRaw(row, col));
this._rowManager = new RowManager(this._snapshot, this._viewModel, rowData);
this._columnManager = new ColumnManager(this._snapshot, columnData);
+ this._spanModel = new SpanModel(this._snapshot.mergeData);
}
/**
@@ -69,6 +73,19 @@ export class Worksheet {
return this._snapshot;
}
+ /**
+ * Set the merge data of the sheet, all the merged cells will be rebuilt.
+ * @param mergeData
+ */
+ setMergeData(mergeData: IRange[]): void {
+ this._snapshot.mergeData = mergeData;
+ this.getSpanModel().rebuild(mergeData);
+ }
+
+ getSpanModel(): SpanModel {
+ return this._spanModel;
+ }
+
/**
* Returns WorkSheet Cell Data Matrix
* @returns
@@ -213,30 +230,111 @@ export class Worksheet {
return new Worksheet(this.unitId, copy, this._styles);
}
+ /**
+ * Get the merged cell list of the sheet.
+ * @returns {IRange[]} merged cell list
+ */
getMergeData(): IRange[] {
- return this._snapshot.mergeData;
+ return this._spanModel.getMergeDataSnapshot();
}
+ /**
+ * Get the merged cell Range of the sheet cell.
+ * @param {number} row The row index of test cell
+ * @param {number} col The column index of test cell
+ * @returns {Nullable<IRange>} The merged cell range of the cell, if the cell is not in a merged cell, return null
+ */
getMergedCell(row: number, col: number): Nullable<IRange> {
- const rectangleList = this._snapshot.mergeData;
- for (let i = 0; i < rectangleList.length; i++) {
- const range = rectangleList[i];
- if (
- Rectangle.intersects(
- {
- startRow: row,
- startColumn: col,
- endRow: row,
- endColumn: col,
- },
- range
- )
- ) {
- return range;
+ return this._spanModel.getMergedCell(row, col);
+ }
+
+ /**
+ * Get the merged cell info list which has intersection with the given range.
+ * @param {number} startRow The start row index of the range
+ * @param {number} startColumn The start column index of the range
+ * @param {number} endRow The end row index of the range
+ * @param {number} endColumn The end column index of the range
+ * @returns {IRange} The merged cell info list which has intersection with the given range or empty array if no merged cell in the range
+ */
+ getMergedCellRange(startRow: number, startColumn: number, endRow: number, endColumn: number): IRange[] {
+ return this._spanModel.getMergedCellRange(startRow, startColumn, endRow, endColumn);
+ }
+
+ /**
+ * Get if the row contains merged cell
+ * @param {number} row The row index
+ * @returns {boolean} Is merge cell across row
+ */
+ isRowContainsMergedCell(row: number): boolean {
+ return this._spanModel.isRowContainsMergedCell(row);
+ }
+
+ /**
+ * Get if the column contains merged cell
+ * @param {number} column The column index
+ * @returns {boolean} Is merge cell across column
+ */
+ isColumnContainsMergedCell(column: number): boolean {
+ return this._spanModel.isColumnContainsMergedCell(column);
+ }
+
+ /**
+ * Get cell info with merge data
+ * @param {number} row - The row index of the cell.
+ * @param {number} column - The column index of the cell.
+ * @type {selectionCell}
+ * @property {number} actualRow - The actual row index of the cell
+ * @property {number} actualColumn - The actual column index of the cell
+ * @property {boolean} isMergedMainCell - Whether the cell is the main cell of the merged cell, only the upper left cell in the merged cell returns true here
+ * @property {boolean} isMerged - Whether the cell is in a merged cell, the upper left cell in the merged cell returns false here
+ * @property {number} endRow - The end row index of the merged cell
+ * @property {number} endColumn - The end column index of the merged cell
+ * @property {number} startRow - The start row index of the merged cell
+ * @property {number} startColumn - The start column index of the merged cell
+ * @returns {selectionCell} - The cell info with merge data
+ */
+ getCellInfoInMergeData(row: number, column: number): ISelectionCell {
+ const mergeRange = this.getMergedCell(row, column);
+ let isMerged = false; // The upper left cell only renders the content
+ let isMergedMainCell = false;
+ let newEndRow = row;
+ let newEndColumn = column;
+ let mergeRow = row;
+ let mergeColumn = column;
+ if (mergeRange) {
+ const {
+ startRow: startRowMarge,
+ endRow: endRowMarge,
+ startColumn: startColumnMarge,
+ endColumn: endColumnMarge,
+ } = mergeRange;
+ if (row === startRowMarge && column === startColumnMarge) {
+ newEndRow = endRowMarge;
+ newEndColumn = endColumnMarge;
+ mergeRow = startRowMarge;
+ mergeColumn = startColumnMarge;
+
+ isMergedMainCell = true;
+ } else if (row >= startRowMarge && row <= endRowMarge && column >= startColumnMarge && column <= endColumnMarge) {
+ newEndRow = endRowMarge;
+ newEndColumn = endColumnMarge;
+ mergeRow = startRowMarge;
+ mergeColumn = startColumnMarge;
+
+ isMerged = true;
}
}
- return null;
+ return {
+ actualRow: row,
+ actualColumn: column,
+ isMergedMainCell,
+ isMerged,
+ endRow: newEndRow,
+ endColumn: newEndColumn,
+ startRow: mergeRow,
+ startColumn: mergeColumn,
+ };
}
/**
@@ -281,9 +379,7 @@ export class Worksheet {
const matrix = this.getCellMatrix();
// get all merged cells
- const mergedCellsInRange = this._snapshot.mergeData.filter((rect) =>
- Rectangle.intersects({ startRow: row, startColumn: col, endRow, endColumn: endCol }, rect)
- );
+ const mergedCellsInRange = this._spanModel.getMergedCellRange(row, col, endRow, endCol);
// iterate all cells in the range
const returnCellMatrix = new ObjectMatrix<ICellData & { rowSpan?: number; colSpan?: number }>();
diff --git a/packages/engine-render/src/basics/tools.ts b/packages/engine-render/src/basics/tools.ts
index 472e064814..a822ec9038 100644
--- a/packages/engine-render/src/basics/tools.ts
+++ b/packages/engine-render/src/basics/tools.ts
@@ -523,14 +523,23 @@ export function getCellPositionByIndex(
};
}
+/**
+ * @description Get the cell position information of the specified row and column, including the position information of the cell and the merge information of the cell
+ * @param {number} row The row index of the cell
+ * @param {number} column The column index of the cell
+ * @param {number[]} rowHeightAccumulation The accumulated height of each row
+ * @param {number[]} columnWidthAccumulation The accumulated width of each column
+ * @param {ISelectionCell} mergeData The merge information of the cell
+ * @returns {ISelectionCellWithMergeInfo} The cell position information of the specified row and column, including the position information of the cell and the merge information of the cell
+ */
export function getCellByIndexWithMergeInfo(
row: number,
column: number,
rowHeightAccumulation: number[],
columnWidthAccumulation: number[],
mergeDataInfo: ISelectionCell
-) {
- // eslint-disable-next-line prefer-const
+): ISelectionCellWithMergeInfo {
+ // eslint-disable-next-line prefer-const
let { startY, endY, startX, endX } = getCellPositionByIndex(
row,
column,
@@ -594,7 +603,9 @@ export function getCellByIndexWithMergeInfo(
mergeInfo,
};
}
-
+/**
+ * @deprecated please use getCellByIndexWithMergeInfo instead
+ */
export function getCellByIndex(
row: number,
column: number,
@@ -672,6 +683,7 @@ export function getCellByIndex(
}
/**
+ * @deprecated please use _hasUnMergedCellInRow in SpreadsheetSkeleton
* Determine whether there are any cells in a row that are not in the merged cells, mainly used for the calculation of auto height
*/
export function hasUnMergedCellInRow(
diff --git a/packages/engine-render/src/components/sheets/extensions/border.ts b/packages/engine-render/src/components/sheets/extensions/border.ts
index 3382923237..c03855f777 100644
--- a/packages/engine-render/src/components/sheets/extensions/border.ts
+++ b/packages/engine-render/src/components/sheets/extensions/border.ts
@@ -41,7 +41,7 @@ export class Border extends SheetExtension {
spreadsheetSkeleton: SpreadsheetSkeleton,
diffRanges: IRange[]
) {
- const { dataMergeCache, stylesCache, overflowCache, worksheet, rowHeightAccumulation, columnTotalWidth, columnWidthAccumulation, rowTotalHeight } = spreadsheetSkeleton;
+ const { stylesCache, overflowCache, worksheet, rowHeightAccumulation, columnTotalWidth, columnWidthAccumulation, rowTotalHeight } = spreadsheetSkeleton;
if (!worksheet) return;
if (
!rowHeightAccumulation ||
@@ -61,19 +61,12 @@ export class Border extends SheetExtension {
const precisionScale = this._getScale(ctx.getScale());
const { border } = stylesCache;
- // eslint-disable-next-line max-lines-per-function
border?.forValue((rowIndex, columnIndex, borderCaches) => {
if (!borderCaches) {
return true;
}
- const cellInfo = this.getCellByIndex(
- rowIndex,
- columnIndex,
- rowHeightAccumulation,
- columnWidthAccumulation,
- dataMergeCache
- );
+ const cellInfo = spreadsheetSkeleton.getCellByIndexWithNoHeader(rowIndex, columnIndex);
const { startY: cellStartY, endY: cellEndY, startX: cellStartX, endX: cellEndX } = cellInfo;
const { isMerged, isMergedMainCell, mergeInfo } = cellInfo;
diff --git a/packages/engine-render/src/components/sheets/extensions/custom.ts b/packages/engine-render/src/components/sheets/extensions/custom.ts
index 009503227e..6fbeffff95 100644
--- a/packages/engine-render/src/components/sheets/extensions/custom.ts
+++ b/packages/engine-render/src/components/sheets/extensions/custom.ts
@@ -36,7 +36,7 @@ export class Custom extends SheetExtension {
override uKey: string = UNIQUE_KEY;
override draw(ctx: UniverRenderingContext, _parentScale: IScale, skeleton: SpreadsheetSkeleton, diffRanges: IRange[] | undefined): void {
- const { rowHeightAccumulation, columnWidthAccumulation, worksheet, dataMergeCache, rowColumnSegment } = skeleton;
+ const { worksheet, rowColumnSegment } = skeleton;
if (!worksheet) {
return;
}
@@ -52,7 +52,7 @@ export class Custom extends SheetExtension {
return;
}
- let primaryWithCoord = this.getCellByIndex(row, col, rowHeightAccumulation, columnWidthAccumulation, dataMergeCache);
+ let primaryWithCoord = skeleton.getCellByIndexWithNoHeader(row, col);
const { mergeInfo } = primaryWithCoord;
if (!this.isRenderDiffRangesByRow(mergeInfo.startRow, mergeInfo.endRow, diffRanges)) {
@@ -78,7 +78,7 @@ export class Custom extends SheetExtension {
return;
}
- primaryWithCoord = this.getCellByIndex(mainCell.row, mainCell.col, rowHeightAccumulation, columnWidthAccumulation, dataMergeCache);
+ primaryWithCoord = skeleton.getCellByIndex(mainCell.row, mainCell.col);
}
const renderInfo = {
diff --git a/packages/engine-render/src/components/sheets/extensions/font.ts b/packages/engine-render/src/components/sheets/extensions/font.ts
index a3ecf9696c..22d8f08ff7 100644
--- a/packages/engine-render/src/components/sheets/extensions/font.ts
+++ b/packages/engine-render/src/components/sheets/extensions/font.ts
@@ -52,7 +52,7 @@ export class Font extends SheetExtension {
diffRanges: IRange[],
moreBoundsInfo: IDrawInfo
) {
- const { stylesCache, dataMergeCache, overflowCache, worksheet } = spreadsheetSkeleton;
+ const { stylesCache, overflowCache, worksheet } = spreadsheetSkeleton;
const { font: fontList } = stylesCache;
if (!spreadsheetSkeleton || !worksheet || !fontList) {
return;
@@ -96,12 +96,9 @@ export class Font extends SheetExtension {
return true;
}
}
- const cellInfo = this.getCellByIndex(
+ const cellInfo = spreadsheetSkeleton.getCellByIndexWithNoHeader(
rowIndex,
- columnIndex,
- rowHeightAccumulation,
- columnWidthAccumulation,
- dataMergeCache
+ columnIndex
);
let { startY, endY, startX, endX } = cellInfo;
const { isMerged, isMergedMainCell, mergeInfo } = cellInfo;
diff --git a/packages/engine-render/src/components/sheets/extensions/marker.ts b/packages/engine-render/src/components/sheets/extensions/marker.ts
index 1e020905a1..01fd04fee2 100644
--- a/packages/engine-render/src/components/sheets/extensions/marker.ts
+++ b/packages/engine-render/src/components/sheets/extensions/marker.ts
@@ -55,13 +55,7 @@ export class Marker extends SheetExtension {
}
let cellData = worksheet.getCell(row, col);
- const cellInfo = this.getCellByIndex(
- row,
- col,
- skeleton.rowHeightAccumulation,
- skeleton.columnWidthAccumulation,
- skeleton.dataMergeCache
- );
+ const cellInfo = skeleton.getCellByIndexWithNoHeader(row, col);
const { isMerged, isMergedMainCell, mergeInfo } = cellInfo;
let { startY, endY, startX, endX } = cellInfo;
diff --git a/packages/engine-render/src/components/sheets/extensions/sheet-extension.ts b/packages/engine-render/src/components/sheets/extensions/sheet-extension.ts
index 71c3dac363..c6e217e6af 100644
--- a/packages/engine-render/src/components/sheets/extensions/sheet-extension.ts
+++ b/packages/engine-render/src/components/sheets/extensions/sheet-extension.ts
@@ -33,6 +33,7 @@ export class SheetExtension extends ComponentExtension<SpreadsheetSkeleton, SHEE
override type = SHEET_EXTENSION_TYPE.GRID;
/**
+ * @deprecated The function maybe cause performance issue, use spreadsheetSkeleton.getCellByIndexWithNoHeader instead.
* Get ISelectionCellWithMergeInfo by cell rowIndex and cell columnIndex.
* The startXY in return value does not include rowHeader and columnHeader.
* @param rowIndex
diff --git a/packages/engine-render/src/components/sheets/sheet-skeleton.ts b/packages/engine-render/src/components/sheets/sheet-skeleton.ts
index 24a883f9c3..c45a6897e8 100644
--- a/packages/engine-render/src/components/sheets/sheet-skeleton.ts
+++ b/packages/engine-render/src/components/sheets/sheet-skeleton.ts
@@ -79,7 +79,6 @@ import {
getCellByIndexWithMergeInfo,
getCellPositionByIndex,
getFontStyleString,
- hasUnMergedCellInRow,
isRectIntersect,
mergeInfoOffset,
} from '../../basics/tools';
@@ -259,8 +258,7 @@ export class SpreadsheetSkeleton extends Skeleton {
endColumn: -1,
};
- private _dataMergeCache: IRange[] = [];
- private _dataMergeCacheMap: Map<string, IRange> = new Map();
+ // private _dataMergeCache: IRange[] = [];
private _overflowCache: ObjectMatrix<IRange> = new ObjectMatrix();
private _stylesCache: IStylesCache = {
background: {},
@@ -330,9 +328,9 @@ export class SpreadsheetSkeleton extends Skeleton {
return this._rowColumnSegment;
}
- get dataMergeCache(): IRange[] {
- return this._dataMergeCache;
- }
+ // get dataMergeCache(): IRange[] {
+ // return this._dataMergeCache;
+ // }
get stylesCache(): IStylesCache {
return this._stylesCache;
@@ -368,7 +366,7 @@ export class SpreadsheetSkeleton extends Skeleton {
this._rowHeaderWidth = 0;
this._columnHeaderHeight = 0;
this._rowColumnSegment = null as any;
- this._dataMergeCache = [];
+ // this._dataMergeCache = [];
this._stylesCache = {
background: {},
backgroundPositions: new ObjectMatrix<ISelectionCellWithMergeInfo>(),
@@ -468,10 +466,11 @@ export class SpreadsheetSkeleton extends Skeleton {
return;
}
- const { mergeData } = this._worksheetData;
+ // const { mergeData } = this._worksheetData;
- this._dataMergeCache = mergeData && this._getMergeCells(mergeData, this._rowColumnSegment);
- this._dataMergeCacheMap = mergeData && this._getMergeCellsCache(mergeData);
+ // // this._dataMergeCache = mergeData && this._getMergeCells(mergeData, this._rowColumnSegment);
+ // const rowColumnSegment = this._rowColumnSegment;
+ // const { startRow, endRow, startColumn, endColumn } = rowColumnSegment;
this._calculateStylesCache();
@@ -492,7 +491,7 @@ export class SpreadsheetSkeleton extends Skeleton {
}
const results: IRowAutoHeightInfo[] = [];
- const { mergeData, rowData } = this._worksheetData;
+ const { rowData } = this._worksheetData;
const rowObjectArray = rowData;
const calculatedRows = new Set<number>();
@@ -510,7 +509,7 @@ export class SpreadsheetSkeleton extends Skeleton {
continue;
}
- const hasUnMergedCell = hasUnMergedCellInRow(rowIndex, startColumn, endColumn, mergeData);
+ const hasUnMergedCell = this._hasUnMergedCellInRow(rowIndex, startColumn, endColumn);
if (hasUnMergedCell) {
const autoHeight = this._calculateRowAutoHeight(rowIndex);
@@ -526,9 +525,26 @@ export class SpreadsheetSkeleton extends Skeleton {
return results;
}
+ private _hasUnMergedCellInRow(rowIndex: number, startColumn: number, endColumn: number): boolean {
+ const mergeData = this.worksheet.getMergeData();
+ if (!mergeData) {
+ return false;
+ }
+
+ for (let i = startColumn; i <= endColumn; i++) {
+ const { isMerged, isMergedMainCell } = this._getCellMergeInfo(rowIndex, i);
+
+ if (!isMerged && !isMergedMainCell) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
// TODO: auto height
private _calculateRowAutoHeight(rowNum: number): number {
- const { columnCount, columnData, mergeData, defaultRowHeight, defaultColumnWidth } = this._worksheetData;
+ const { columnCount, columnData, defaultRowHeight, defaultColumnWidth } = this._worksheetData;
let height = defaultRowHeight;
const worksheet = this.worksheet;
@@ -539,7 +555,7 @@ export class SpreadsheetSkeleton extends Skeleton {
for (let i = 0; i < columnCount; i++) {
// When calculating the automatic height of a row, if a cell is in a merged cell,
// skip the cell directly, which currently follows the logic of Excel
- const { isMerged, isMergedMainCell } = this._getCellMergeInfo(rowNum, i, mergeData);
+ const { isMerged, isMergedMainCell } = this._getCellMergeInfo(rowNum, i);
if (isMerged || isMergedMainCell) {
continue;
@@ -941,7 +957,7 @@ export class SpreadsheetSkeleton extends Skeleton {
}
if (closeFirst) {
- // check if upper row was closer than current
+ // check if upper row was closer than current
if (Math.abs(rowHeightAccumulation[row] - offsetY) < Math.abs(offsetY - (rowHeightAccumulation[row - 1] ?? 0))) {
row = row + 1;
}
@@ -1017,7 +1033,7 @@ export class SpreadsheetSkeleton extends Skeleton {
column,
rowHeightAccumulation,
columnWidthAccumulation,
- this._getCellMergeInfo(row, column, this._worksheetData.mergeData)
+ this._getCellMergeInfo(row, column)
);
const { isMerged, isMergedMainCell } = primary;
let { startY, endY, startX, endX, mergeInfo } = primary;
@@ -1050,7 +1066,7 @@ export class SpreadsheetSkeleton extends Skeleton {
column,
rowHeightAccumulation,
columnWidthAccumulation,
- this._getCellMergeInfo(row, column, this._worksheetData.mergeData)
+ this._getCellMergeInfo(row, column)
);
const { isMerged, isMergedMainCell } = primary;
@@ -1316,7 +1332,7 @@ export class SpreadsheetSkeleton extends Skeleton {
column,
this.rowHeightAccumulation,
this.columnWidthAccumulation,
- this._getCellMergeInfo(row, column, this._worksheetData.mergeData)
+ this._getCellMergeInfo(row, column)
);
const cellWidth = endX - startX;
const cellHeight = endY - startY;
@@ -1354,7 +1370,7 @@ export class SpreadsheetSkeleton extends Skeleton {
column,
this.rowHeightAccumulation,
this.columnWidthAccumulation,
- this._getCellMergeInfo(row, column, this._worksheetData.mergeData)
+ this._getCellMergeInfo(row, column)
);
const cellHeight = endY - startY;
@@ -1617,29 +1633,8 @@ export class SpreadsheetSkeleton extends Skeleton {
}
intersectMergeRange(row: number, column: number): boolean {
- const dataMergeCache = this.dataMergeCache;
- for (const dataCache of dataMergeCache) {
- const {
- startRow: startRowMargeIndex,
- endRow: endRowMargeIndex,
- startColumn: startColumnMargeIndex,
- endColumn: endColumnMargeIndex,
- } = dataCache;
- if (
- row >= startRowMargeIndex &&
- row <= endRowMargeIndex &&
- column >= startColumnMargeIndex &&
- column <= endColumnMargeIndex
- ) {
- return true;
- }
- }
- // dataMergeCache?.forEach((r, dataMergeRow) => {
- // dataMergeRow?.forEach((c, dataCache) => {
-
- // });
- // });
- return false;
+ const mergedData = this.worksheet.getMergedCell(row, column);
+ return Boolean(mergedData);
}
// private _getMergeRangeCache() {
@@ -1656,15 +1651,36 @@ export class SpreadsheetSkeleton extends Skeleton {
// return mergeRangeCache;
// }
+ /**
+ * get the current row and column segment visible merge data
+ * @returns {IRange} The visible merge data
+ */
+ public getCurrentRowColumnSegmentMergeData(range?: IRange): IRange[] {
+ const endColumnLast = this.columnWidthAccumulation.length - 1;
+ if (!range) {
+ const endRow = this.rowHeightAccumulation.length - 1;
+ range = { startRow: 0, startColumn: 0, endRow, endColumn: endColumnLast };
+ } else {
+ range = {
+ startRow: range.startRow,
+ endRow: range.endRow,
+ endColumn: endColumnLast,
+ startColumn: 0,
+ };
+ }
+
+ return this.worksheet.getSpanModel().getMergedCellRangeForSkeleton(range.startRow, range.startColumn, range.endRow, range.endColumn);
+ }
+
private _calculateStylesCache(): void {
- const dataMergeCaches = this._dataMergeCache;
const rowColumnSegment = this._rowColumnSegment;
const columnWidthAccumulation = this.columnWidthAccumulation;
const { startRow, endRow, startColumn, endColumn } = rowColumnSegment;
if (endColumn === -1 || endRow === -1) return;
- for (const mergeRange of dataMergeCaches) {
+ const mergeRanges = this.getCurrentRowColumnSegmentMergeData(this._rowColumnSegment);
+ for (const mergeRange of mergeRanges) {
this._setStylesCache(mergeRange.startRow, mergeRange.startColumn, {
mergeRange,
});
@@ -1755,11 +1771,7 @@ export class SpreadsheetSkeleton extends Skeleton {
const hidden = this.worksheet.getColVisible(col) === false || this.worksheet.getRowVisible(row) === false;
if (hidden) {
- const { isMerged, isMergedMainCell } = this._getCellMergeInfo(
- row,
- col,
- this._dataMergeCache
- );
+ const { isMerged, isMergedMainCell } = this._getCellMergeInfo(row, col);
if (isMerged && !isMergedMainCell) {
// If the cell is merged and is not the main cell, the cell is not rendered.
@@ -2145,65 +2157,8 @@ export class SpreadsheetSkeleton extends Skeleton {
} as ICellOtherConfig;
}
- private _getMergeCellsCache(mergeData: IRange[]) {
- const map = new Map<string, IRange>();
- mergeData.forEach((range) => {
- for (let r = range.startRow; r <= range.endRow; r++) {
- for (let c = range.startColumn; c <= range.endColumn; c++) {
- map.set(`${r}-${c}`, range);
- }
- }
- });
- return map;
- }
-
- private _getCellMergeInfo(row: number, column: number, mergeData: IRange[]): ISelectionCell {
- if (!this._dataMergeCacheMap) {
- this._dataMergeCacheMap = this._getMergeCellsCache(mergeData);
- }
- const key = `${row}-${column}`;
- const mergeRange = this._dataMergeCacheMap.get(key);
-
- let isMerged = false; // The upper left cell only renders the content
- let isMergedMainCell = false;
- let newEndRow = row;
- let newEndColumn = column;
- let mergeRow = row;
- let mergeColumn = column;
- if (mergeRange) {
- const {
- startRow: startRowMarge,
- endRow: endRowMarge,
- startColumn: startColumnMarge,
- endColumn: endColumnMarge,
- } = mergeRange;
- if (row === startRowMarge && column === startColumnMarge) {
- newEndRow = endRowMarge;
- newEndColumn = endColumnMarge;
- mergeRow = startRowMarge;
- mergeColumn = startColumnMarge;
-
- isMergedMainCell = true;
- } else if (row >= startRowMarge && row <= endRowMarge && column >= startColumnMarge && column <= endColumnMarge) {
- newEndRow = endRowMarge;
- newEndColumn = endColumnMarge;
- mergeRow = startRowMarge;
- mergeColumn = startColumnMarge;
-
- isMerged = true;
- }
- }
-
- return {
- actualRow: row,
- actualColumn: column,
- isMergedMainCell,
- isMerged,
- endRow: newEndRow,
- endColumn: newEndColumn,
- startRow: mergeRow,
- startColumn: mergeColumn,
- };
+ private _getCellMergeInfo(row: number, column: number): ISelectionCell {
+ return this.worksheet.getCellInfoInMergeData(row, column);
}
/**
diff --git a/packages/engine-render/src/components/sheets/spreadsheet.ts b/packages/engine-render/src/components/sheets/spreadsheet.ts
index 155a9a7ad9..00a3acfd26 100644
--- a/packages/engine-render/src/components/sheets/spreadsheet.ts
+++ b/packages/engine-render/src/components/sheets/spreadsheet.ts
@@ -545,7 +545,8 @@ export class Spreadsheet extends SheetComponent {
return;
}
- const { rowColumnSegment, dataMergeCache: mergeCellRanges, overflowCache, showGridlines } = spreadsheetSkeleton;
+ const { rowColumnSegment, overflowCache, showGridlines } = spreadsheetSkeleton;
+ const mergeCellRanges = spreadsheetSkeleton.getCurrentRowColumnSegmentMergeData(rowColumnSegment);
const { startRow, endRow, startColumn, endColumn } = rowColumnSegment;
if (!spreadsheetSkeleton || showGridlines === BooleanNumber.FALSE || this._forceDisableGridlines) {
return;
diff --git a/packages/facade/src/apis/sheets/f-range.ts b/packages/facade/src/apis/sheets/f-range.ts
index 829437e919..c3c732a605 100644
--- a/packages/facade/src/apis/sheets/f-range.ts
+++ b/packages/facade/src/apis/sheets/f-range.ts
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-import { BooleanNumber, CustomRangeType, Dimension, generateRandomId, ICommandService, Inject, Injector, Rectangle, Tools, UserManagerService, WrapStrategy } from '@univerjs/core';
+import { BooleanNumber, CustomRangeType, Dimension, generateRandomId, ICommandService, Inject, Injector, Tools, UserManagerService, WrapStrategy } from '@univerjs/core';
import { FormulaDataModel } from '@univerjs/engine-formula';
import { IRenderManagerService } from '@univerjs/engine-render';
import {
@@ -945,8 +945,8 @@ export class FRange {
* @returns {boolean} is overlap with a merged cell
*/
isPartOfMerge(): boolean {
- const mergeData = this._worksheet.getMergeData();
- return mergeData.some((merge) => Rectangle.intersects(this._range, merge));
+ const { startRow, startColumn, endRow, endColumn } = this._range;
+ return this._worksheet.getMergedCellRange(startRow, startColumn, endRow, endColumn).length > 0;
}
/**
diff --git a/packages/facade/src/apis/sheets/f-worksheet.ts b/packages/facade/src/apis/sheets/f-worksheet.ts
index 33bef74497..a70c904365 100644
--- a/packages/facade/src/apis/sheets/f-worksheet.ts
+++ b/packages/facade/src/apis/sheets/f-worksheet.ts
@@ -838,6 +838,20 @@ export class FWorksheet {
return snapshot.mergeData.map((merge) => this._injector.createInstance(FRange, this._workbook, this._worksheet, merge));
}
+ /**
+ * Get the merged cell data of the specified row and column.
+ * @param {number} row The row index.
+ * @param {number} column The column index.
+ * @returns {FRange|undefined} The merged cell data, or undefined if the cell is not merged.
+ */
+ getCellMergeData(row: number, column: number): FRange | undefined {
+ const worksheet = this._worksheet;
+ const mergeData = worksheet.getMergedCell(row, column);
+ if (mergeData) {
+ return this._injector.createInstance(FRange, this._workbook, this._worksheet, mergeData);
+ }
+ }
+
// #endregion
/**
diff --git a/packages/sheets-conditional-formatting/src/render/data-bar.render.ts b/packages/sheets-conditional-formatting/src/render/data-bar.render.ts
index e0aa701026..48fdb622e9 100644
--- a/packages/sheets-conditional-formatting/src/render/data-bar.render.ts
+++ b/packages/sheets-conditional-formatting/src/render/data-bar.render.ts
@@ -41,8 +41,8 @@ export class DataBar extends SheetExtension {
spreadsheetSkeleton: SpreadsheetSkeleton,
diffRanges: IRange[]
) {
- const { rowHeightAccumulation, columnWidthAccumulation, worksheet, dataMergeCache } =
- spreadsheetSkeleton;
+ const { worksheet } = spreadsheetSkeleton;
+
if (!worksheet) {
return false;
}
@@ -55,7 +55,7 @@ export class DataBar extends SheetExtension {
const cellData = worksheet.getCell(row, col) as IDataBarCellData;
if (cellData && cellData.dataBar) {
const { color, value, startPoint, isGradient } = cellData.dataBar;
- const cellInfo = this.getCellByIndex(row, col, rowHeightAccumulation, columnWidthAccumulation, dataMergeCache);
+ const cellInfo = spreadsheetSkeleton.getCellByIndex(row, col);
let { isMerged, isMergedMainCell, mergeInfo, startY, endY, startX, endX } = cellInfo;
if (isMerged) {
return;
diff --git a/packages/sheets-conditional-formatting/src/render/icon.render.ts b/packages/sheets-conditional-formatting/src/render/icon.render.ts
index 0bb374aab5..fb25fbc459 100644
--- a/packages/sheets-conditional-formatting/src/render/icon.render.ts
+++ b/packages/sheets-conditional-formatting/src/render/icon.render.ts
@@ -48,8 +48,7 @@ export class ConditionalFormattingIcon extends SheetExtension {
spreadsheetSkeleton: SpreadsheetSkeleton,
diffRanges: IRange[]
) {
- const { rowHeightAccumulation, columnWidthAccumulation, worksheet, dataMergeCache } =
- spreadsheetSkeleton;
+ const { worksheet } = spreadsheetSkeleton;
if (!worksheet) {
return false;
}
@@ -69,7 +68,7 @@ export class ConditionalFormattingIcon extends SheetExtension {
if (!icon) {
return;
}
- const cellInfo = this.getCellByIndex(row, col, rowHeightAccumulation, columnWidthAccumulation, dataMergeCache);
+ const cellInfo = spreadsheetSkeleton.getCellByIndexWithNoHeader(row, col);
let { isMerged, isMergedMainCell, mergeInfo, startY, endY, startX, endX } = cellInfo;
if (isMerged) {
return;
diff --git a/packages/sheets-data-validation/src/controllers/dv-render.controller.ts b/packages/sheets-data-validation/src/controllers/dv-render.controller.ts
index 04735d4c7f..2a54987b9d 100644
--- a/packages/sheets-data-validation/src/controllers/dv-render.controller.ts
+++ b/packages/sheets-data-validation/src/controllers/dv-render.controller.ts
@@ -254,10 +254,11 @@ export class SheetsDataValidationRenderController extends RxDisposable {
...extra.interceptorStyle,
},
interceptorAutoHeight: () => {
- const mergeCell = skeleton.mergeData.find((range) => {
- const { startColumn, startRow, endColumn, endRow } = range;
- return row >= startRow && col >= startColumn && row <= endRow && col <= endColumn;
- });
+ // const mergeCell = skeleton.mergeData.find((range) => {
+ // const { startColumn, startRow, endColumn, endRow } = range;
+ // return row >= startRow && col >= startColumn && row <= endRow && col <= endColumn;
+ // });
+ const mergeCell = skeleton.worksheet.getMergedCell(row, col);
const info: ICellRenderContext = {
data: {
@@ -458,10 +459,11 @@ export class SheetsDataValidationMobileRenderController extends RxDisposable {
...extra.interceptorStyle,
},
interceptorAutoHeight: () => {
- const mergeCell = skeleton.mergeData.find((range) => {
- const { startColumn, startRow, endColumn, endRow } = range;
- return row >= startRow && col >= startColumn && row <= endRow && col <= endColumn;
- });
+ // const mergeCell = skeleton.mergeData.find((range) => {
+ // const { startColumn, startRow, endColumn, endRow } = range;
+ // return row >= startRow && col >= startColumn && row <= endRow && col <= endColumn;
+ // });
+ const mergeCell = skeleton.worksheet.getMergedCell(row, col);
const info: ICellRenderContext = {
data: {
diff --git a/packages/sheets-formula/src/controllers/prompt.controller.ts b/packages/sheets-formula/src/controllers/prompt.controller.ts
index 62cad9335f..3a9989365e 100644
--- a/packages/sheets-formula/src/controllers/prompt.controller.ts
+++ b/packages/sheets-formula/src/controllers/prompt.controller.ts
@@ -25,7 +25,6 @@ import {
DOCS_NORMAL_EDITOR_UNIT_ID_KEY,
FOCUSING_EDITOR_INPUT_FORMULA,
FORMULA_EDITOR_ACTIVATED,
- getCellInfoInMergeData,
ICommandService,
IContextService,
Inject,
@@ -1514,7 +1513,19 @@ export class PromptController extends Disposable {
}
let { startRow, endRow, startColumn, endColumn } = toRange;
- const primary = getCellInfoInMergeData(startRow, startColumn, skeleton?.mergeData);
+ // const primary = getCellInfoInMergeData(startRow, startColumn, skeleton?.mergeData);
+ const primary = skeleton
+ ? skeleton.worksheet.getCellInfoInMergeData(startRow, startColumn)
+ : {
+ actualRow: startRow,
+ actualColumn: startColumn,
+ isMergedMainCell: false,
+ isMerged: false,
+ endRow: startRow,
+ endColumn: startColumn,
+ startRow,
+ startColumn,
+ };
if (primary) {
const {
diff --git a/packages/sheets-ui/src/common/utils.ts b/packages/sheets-ui/src/common/utils.ts
index 693b143f29..656ff75a3f 100644
--- a/packages/sheets-ui/src/common/utils.ts
+++ b/packages/sheets-ui/src/common/utils.ts
@@ -125,10 +125,11 @@ export function getCellIndexByOffsetWithMerge(offsetX: number, offsetY: number,
const cellPos = skeleton.getCellPositionByOffset(offsetX, offsetY, scaleX, scaleY, scrollXY);
- const mergeCell = skeleton.mergeData.find((range) => {
- const { startColumn, startRow, endColumn, endRow } = range;
- return cellPos.row >= startRow && cellPos.column >= startColumn && cellPos.row <= endRow && cellPos.column <= endColumn;
- });
+ // const mergeCell = skeleton.mergeData.find((range) => {
+ // const { startColumn, startRow, endColumn, endRow } = range;
+ // return cellPos.row >= startRow && cellPos.column >= startColumn && cellPos.row <= endRow && cellPos.column <= endColumn;
+ // });
+ const mergeCell = skeleton.worksheet.getMergedCell(cellPos.row, cellPos.column);
const params = {
actualRow: mergeCell ? mergeCell.startRow : cellPos.row,
diff --git a/packages/sheets-ui/src/controllers/auto-fill.controller.ts b/packages/sheets-ui/src/controllers/auto-fill.controller.ts
index 22d9b17c04..08382eac73 100644
--- a/packages/sheets-ui/src/controllers/auto-fill.controller.ts
+++ b/packages/sheets-ui/src/controllers/auto-fill.controller.ts
@@ -18,7 +18,6 @@ import {
Direction,
Disposable,
DisposableCollection,
- getCellInfoInMergeData,
ICommandService,
Inject,
Injector,
@@ -280,7 +279,7 @@ export class AutoFillController extends Disposable {
);
}
- // eslint-disable-next-line max-lines-per-function, complexity
+ // eslint-disable-next-line max-lines-per-function, complexity
private _triggerAutoFill(source: IRange, selection: IRange) {
// if source range === dest range, do nothing;
if (
@@ -640,15 +639,10 @@ export class AutoFillController extends Disposable {
throw new Error('No active sheet found');
}
- const mergeData = worksheet.getMergeData();
const applyMergeRanges = [];
for (let i = source.startRow; i <= source.endRow; i++) {
for (let j = source.startColumn; j <= source.endColumn; j++) {
- const { isMergedMainCell, startRow, startColumn, endRow, endColumn } = getCellInfoInMergeData(
- i,
- j,
- mergeData
- );
+ const { isMergedMainCell, startRow, startColumn, endRow, endColumn } = worksheet.getCellInfoInMergeData(i, j);
if (isMergedMainCell) {
if (direction === Direction.DOWN) {
let windowStartRow = startRow + csLen;
diff --git a/packages/sheets-ui/src/controllers/cell-custom-render.controller.ts b/packages/sheets-ui/src/controllers/cell-custom-render.controller.ts
index 7920032092..c7d4150799 100644
--- a/packages/sheets-ui/src/controllers/cell-custom-render.controller.ts
+++ b/packages/sheets-ui/src/controllers/cell-custom-render.controller.ts
@@ -14,12 +14,12 @@
* limitations under the License.
*/
-import type { ICellCustomRender, ICellRenderContext, Nullable, UniverInstanceService, Workbook } from '@univerjs/core';
import { Disposable, DisposableCollection, Inject, IUniverInstanceService, LifecycleStages, OnLifecycle, sortRules } from '@univerjs/core';
-import type { IMouseEvent, IPointerEvent, IRenderContext, IRenderModule, RenderManagerService, Spreadsheet } from '@univerjs/engine-render';
import { IRenderManagerService, Vector2 } from '@univerjs/engine-render';
-import type { ISheetSkeletonManagerParam } from '../services/sheet-skeleton-manager.service';
+import type { ICellCustomRender, ICellRenderContext, Nullable, UniverInstanceService, Workbook } from '@univerjs/core';
+import type { IMouseEvent, IPointerEvent, IRenderContext, IRenderModule, RenderManagerService, Spreadsheet } from '@univerjs/engine-render';
import { SheetSkeletonManagerService } from '../services/sheet-skeleton-manager.service';
+import type { ISheetSkeletonManagerParam } from '../services/sheet-skeleton-manager.service';
@OnLifecycle(LifecycleStages.Rendered, CellCustomRenderController)
export class CellCustomRenderController extends Disposable implements IRenderModule {
@@ -82,10 +82,11 @@ export class CellCustomRenderController extends Disposable implements IRenderMod
const cellPos = skeleton.getCellPositionByOffset(offsetX, offsetY, scaleX, scaleY, scrollXY);
- const mergeCell = skeleton.mergeData.find((range) => {
- const { startColumn, startRow, endColumn, endRow } = range;
- return cellPos.row >= startRow && cellPos.column >= startColumn && cellPos.row <= endRow && cellPos.column <= endColumn;
- });
+ // const mergeCell = skeleton.mergeData.find((range) => {
+ // const { startColumn, startRow, endColumn, endRow } = range;
+ // return cellPos.row >= startRow && cellPos.column >= startColumn && cellPos.row <= endRow && cellPos.column <= endColumn;
+ // });
+ const mergeCell = skeleton.worksheet.getMergedCell(cellPos.row, cellPos.column);
const cellIndex = {
actualRow: mergeCell ? mergeCell.startRow : cellPos.row,
diff --git a/packages/sheets-ui/src/controllers/format-painter/format-painter.controller.ts b/packages/sheets-ui/src/controllers/format-painter/format-painter.controller.ts
index e492b1b289..71fdea6179 100644
--- a/packages/sheets-ui/src/controllers/format-painter/format-painter.controller.ts
+++ b/packages/sheets-ui/src/controllers/format-painter/format-painter.controller.ts
@@ -14,10 +14,8 @@
* limitations under the License.
*/
-import type { ICellData, IMutationInfo, IRange, IStyleData, Workbook } from '@univerjs/core';
import {
Disposable,
- getCellInfoInMergeData,
ICommandService,
Inject,
Injector,
@@ -28,18 +26,19 @@ import {
Tools,
UniverInstanceType,
} from '@univerjs/core';
+import { IRenderManagerService } from '@univerjs/engine-render';
-import type { IAddWorksheetMergeMutationParams, IRemoveWorksheetMergeMutationParams, ISetRangeValuesMutationParams } from '@univerjs/sheets';
import { AddMergeUndoMutationFactory, AddWorksheetMergeMutation, getAddMergeMutationRangeByType, RemoveMergeUndoMutationFactory, RemoveWorksheetMergeMutation, SetRangeValuesCommand, SetRangeValuesMutation, SetRangeValuesUndoMutationFactory, SheetInterceptorService, SheetsSelectionsService } from '@univerjs/sheets';
-import { IRenderManagerService } from '@univerjs/engine-render';
+import type { ICellData, IMutationInfo, IRange, IStyleData, Workbook } from '@univerjs/core';
+import type { IAddWorksheetMergeMutationParams, IRemoveWorksheetMergeMutationParams, ISetRangeValuesMutationParams } from '@univerjs/sheets';
import {
ApplyFormatPainterCommand,
SetOnceFormatPainterCommand,
} from '../../commands/commands/set-format-painter.command';
-import type { IFormatPainterHook, ISelectionFormatInfo } from '../../services/format-painter/format-painter.service';
-import { FormatPainterStatus, IFormatPainterService } from '../../services/format-painter/format-painter.service';
import { checkCellContentInRanges, getClearContentMutationParamsForRanges } from '../../common/utils';
+import { FormatPainterStatus, IFormatPainterService } from '../../services/format-painter/format-painter.service';
import { ISheetSelectionRenderService } from '../../services/selection/base-selection-render.service';
+import type { IFormatPainterHook, ISelectionFormatInfo } from '../../services/format-painter/format-painter.service';
@OnLifecycle(LifecycleStages.Steady, FormatPainterController)
export class FormatPainterController extends Disposable {
@@ -118,7 +117,6 @@ export class FormatPainterController extends Disposable {
const worksheet = workbook?.getActiveSheet();
if (!worksheet) return null;
const cellData = worksheet.getCellMatrix();
- const mergeData = worksheet.getMergeData();
const styles = workbook.getStyles();
const stylesMatrix = new ObjectMatrix<IStyleData>();
@@ -127,7 +125,7 @@ export class FormatPainterController extends Disposable {
for (let c = startColumn; c <= endColumn; c++) {
const cell = cellData.getValue(r, c) as ICellData;
stylesMatrix.setValue(r, c, styles.getStyleByCell(cell) || {});
- const { isMergedMainCell, ...mergeInfo } = getCellInfoInMergeData(r, c, mergeData);
+ const { isMergedMainCell, ...mergeInfo } = worksheet.getCellInfoInMergeData(r, c);
if (isMergedMainCell) {
merges.push({
startRow: mergeInfo.startRow,
diff --git a/packages/sheets-ui/src/services/selection/selection-shape-extension.ts b/packages/sheets-ui/src/services/selection/selection-shape-extension.ts
index 54a5bfa383..b77496682b 100644
--- a/packages/sheets-ui/src/services/selection/selection-shape-extension.ts
+++ b/packages/sheets-ui/src/services/selection/selection-shape-extension.ts
@@ -14,12 +14,12 @@
* limitations under the License.
*/
+import { ColorKit, Quantity, UniverInstanceType } from '@univerjs/core';
+import { CURSOR_TYPE, IRenderManagerService, Rect, ScrollTimer, ScrollTimerType, SHEET_VIEWPORT_KEY, Vector2 } from '@univerjs/engine-render';
+import { getNormalSelectionStyle, SELECTION_CONTROL_BORDER_BUFFER_WIDTH } from '@univerjs/sheets';
/* eslint-disable max-lines-per-function */
import type { IFreeze, Injector, IRangeWithCoord, Nullable, ThemeService } from '@univerjs/core';
-import { ColorKit, Quantity, UniverInstanceType } from '@univerjs/core';
import type { IMouseEvent, IPointerEvent, Scene, SpreadsheetSkeleton, Viewport } from '@univerjs/engine-render';
-import { CURSOR_TYPE, IRenderManagerService, isRectIntersect, Rect, ScrollTimer, ScrollTimerType, SHEET_VIEWPORT_KEY, Vector2 } from '@univerjs/engine-render';
-import { getNormalSelectionStyle, SELECTION_CONTROL_BORDER_BUFFER_WIDTH } from '@univerjs/sheets';
import type { Subscription } from 'rxjs';
import { SheetSkeletonManagerService } from '../sheet-skeleton-manager.service';
@@ -112,7 +112,10 @@ export class SelectionShapeExtension {
private _getFreeze() {
const renderManagerService = this._injector.get(IRenderManagerService);
const freeze = renderManagerService.withCurrentTypeOfUnit(UniverInstanceType.UNIVER_SHEET, SheetSkeletonManagerService)
- ?.getCurrent()?.skeleton.getWorksheetConfig().freeze;
+ ?.getCurrent()
+ ?.skeleton
+ .getWorksheetConfig()
+ .freeze;
return freeze;
}
@@ -159,7 +162,8 @@ export class SelectionShapeExtension {
[leftControl, rightControl, topControl, bottomControl].forEach((control) => {
control.onPointerEnter$.subscribeEvent(() => {
const permissionCheck = this._injector.get(ISheetSelectionRenderService, Quantity.OPTIONAL)
- ?.interceptor.fetchThroughInterceptors(RANGE_MOVE_PERMISSION_CHECK)(false, null);
+ ?.interceptor
+ .fetchThroughInterceptors(RANGE_MOVE_PERMISSION_CHECK)(false, null);
if (permissionCheck === false) {
return;
}
@@ -338,7 +342,8 @@ export class SelectionShapeExtension {
const { offsetX: moveOffsetX, offsetY: moveOffsetY } = moveEvt;
const permissionCheck = this._injector.get(ISheetSelectionRenderService, Quantity.OPTIONAL)
- ?.interceptor.fetchThroughInterceptors(RANGE_MOVE_PERMISSION_CHECK)(false, null);
+ ?.interceptor
+ .fetchThroughInterceptors(RANGE_MOVE_PERMISSION_CHECK)(false, null);
if (permissionCheck === false) {
return;
}
@@ -918,38 +923,7 @@ export class SelectionShapeExtension {
}
private _hasMergeInRange(startRow: number, startColumn: number, endRow: number, endColumn: number) {
- const mergeData = this._skeleton.mergeData;
- if (!mergeData) {
- return false;
- }
-
- for (const data of mergeData) {
- const {
- startRow: mainStartRow,
- startColumn: mainStartColumn,
- endRow: mainEndRow,
- endColumn: mainEndColumn,
- } = data;
- const rect1 = {
- left: startColumn,
- top: startRow,
- right: endColumn,
- bottom: endRow,
- };
-
- const rect2 = {
- left: mainStartColumn,
- top: mainStartRow,
- right: mainEndColumn,
- bottom: mainEndRow,
- };
-
- if (isRectIntersect(rect1, rect2)) {
- return true;
- }
- }
-
- return false;
+ return this._skeleton.worksheet.getMergedCellRange(startRow, startColumn, endRow, endColumn).length > 0;
}
private _swapPositions(startRow: number, startColumn: number, endRow: number, endColumn: number) {
diff --git a/packages/sheets-ui/src/views/permission/extensions/range-protection.render.ts b/packages/sheets-ui/src/views/permission/extensions/range-protection.render.ts
index 65ee43ad96..9314ac95f0 100644
--- a/packages/sheets-ui/src/views/permission/extensions/range-protection.render.ts
+++ b/packages/sheets-ui/src/views/permission/extensions/range-protection.render.ts
@@ -53,8 +53,8 @@ export abstract class RangeProtectionRenderExtension extends SheetExtension {
_parentScale: IScale,
spreadsheetSkeleton: SpreadsheetSkeleton
) {
- const { rowHeightAccumulation, columnWidthAccumulation, worksheet, dataMergeCache } =
- spreadsheetSkeleton;
+ const { worksheet } = spreadsheetSkeleton;
+
if (!worksheet) {
return;
}
@@ -85,8 +85,8 @@ export abstract class RangeProtectionRenderExtension extends SheetExtension {
}
this.renderCache.add(config.ruleId);
config.ranges!.forEach((range) => {
- const start = this.getCellByIndex(range.startRow, range.startColumn, rowHeightAccumulation, columnWidthAccumulation, dataMergeCache);
- const end = this.getCellByIndex(range.endRow, range.endColumn, rowHeightAccumulation, columnWidthAccumulation, dataMergeCache);
+ const start = spreadsheetSkeleton.getCellByIndexWithNoHeader(range.startRow, range.startColumn);
+ const end = spreadsheetSkeleton.getCellByIndexWithNoHeader(range.endRow, range.endColumn);
ctx.fillRect(start.startX, start.startY, end.endX - start.startX, end.endY - start.startY);
});
}
diff --git a/packages/sheets-ui/src/views/permission/extensions/worksheet-permission.render.ts b/packages/sheets-ui/src/views/permission/extensions/worksheet-permission.render.ts
index c1849a3862..6db56e91ef 100644
--- a/packages/sheets-ui/src/views/permission/extensions/worksheet-permission.render.ts
+++ b/packages/sheets-ui/src/views/permission/extensions/worksheet-permission.render.ts
@@ -43,8 +43,8 @@ export class WorksheetProtectionRenderExtension extends SheetExtension {
_parentScale: IScale,
spreadsheetSkeleton: SpreadsheetSkeleton
) {
- const { rowHeightAccumulation, columnWidthAccumulation, worksheet, dataMergeCache } =
- spreadsheetSkeleton;
+ const { worksheet } = spreadsheetSkeleton;
+
if (!worksheet) {
return false;
}
@@ -54,8 +54,8 @@ export class WorksheetProtectionRenderExtension extends SheetExtension {
this._pattern = ctx.createPattern(this._img, 'repeat');
}
const { startRow, startColumn, endRow, endColumn } = spreadsheetSkeleton.rowColumnSegment;
- const start = this.getCellByIndex(startRow, startColumn, rowHeightAccumulation, columnWidthAccumulation, dataMergeCache);
- const end = this.getCellByIndex(endRow, endColumn, rowHeightAccumulation, columnWidthAccumulation, dataMergeCache);
+ const start = spreadsheetSkeleton.getCellByIndexWithNoHeader(startRow, startColumn);
+ const end = spreadsheetSkeleton.getCellByIndexWithNoHeader(endRow, endColumn);
const { hasWorksheetRule = false, selectionProtection = [] } = worksheet.getCell(startRow, startColumn) as IWorksheetProtectionRenderCellData || {};
if (!this._pattern) {
diff --git a/packages/sheets/src/basics/expand-range.ts b/packages/sheets/src/basics/expand-range.ts
index 9c7a8cd9e1..d85879ba69 100644
--- a/packages/sheets/src/basics/expand-range.ts
+++ b/packages/sheets/src/basics/expand-range.ts
@@ -14,8 +14,8 @@
* limitations under the License.
*/
-import type { ICellData, IRange, Worksheet } from '@univerjs/core';
import { createRowColIter, ObjectMatrix, Rectangle } from '@univerjs/core';
+import type { ICellData, IRange, Worksheet } from '@univerjs/core';
export interface IExpandParams {
left?: boolean;
@@ -56,10 +56,7 @@ function getMatrixWithSpanInfo(worksheet: Worksheet, startRow: number, startColu
const matrix = worksheet.getCellMatrix();
// get all merged cells
- const mergedCellsInRange = worksheet.getSnapshot().mergeData.filter((rect) =>
- Rectangle.intersects({ startRow, startColumn, endRow, endColumn }, rect)
- );
-
+ const mergedCellsInRange = worksheet.getSpanModel().getMergedCellRange(startRow, startColumn, endRow, endColumn);
// iterate all cells in the range
const returnCellMatrix = new ObjectMatrix<IMatrixWithSpanInfo>();
diff --git a/packages/sheets/src/basics/selection.ts b/packages/sheets/src/basics/selection.ts
index 7f6ef51601..ab4a224c31 100644
--- a/packages/sheets/src/basics/selection.ts
+++ b/packages/sheets/src/basics/selection.ts
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+import { ColorKit, getCellInfoInMergeData, makeCellRangeToRangeData } from '@univerjs/core';
import type {
IRange,
ISelection,
@@ -22,7 +23,6 @@ import type {
Nullable,
ThemeService,
} from '@univerjs/core';
-import { ColorKit, getCellInfoInMergeData, makeCellRangeToRangeData } from '@univerjs/core';
export const SELECTION_CONTROL_BORDER_BUFFER_WIDTH = 1.5; // The draggable range of the selection is too thin, making it easy for users to miss. Therefore, a buffer gap is provided to make it easier for users to select.
@@ -233,6 +233,7 @@ export function convertPrimaryWithCoordToPrimary(primaryWithCoord: ISelectionCel
}
/**
+ * @deprecated Use worksheet.getCellInfoInMergeData or SpreadsheetSkeleton.getCellByIndex instead
* Convert the coordinates of a single cell into a selection data.
* @param row Specified Row Coordinate
* @param column Specified Column Coordinate
diff --git a/packages/sheets/src/commands/commands/move-rows-cols.command.ts b/packages/sheets/src/commands/commands/move-rows-cols.command.ts
index 4258e56b54..569bacd8ad 100644
--- a/packages/sheets/src/commands/commands/move-rows-cols.command.ts
+++ b/packages/sheets/src/commands/commands/move-rows-cols.command.ts
@@ -14,7 +14,6 @@
* limitations under the License.
*/
-import type { IAccessor, ICommand, IRange } from '@univerjs/core';
import {
CommandType,
ErrorService,
@@ -26,22 +25,22 @@ import {
Rectangle,
sequenceExecute,
} from '@univerjs/core';
+import type { IAccessor, ICommand, IRange, Worksheet } from '@univerjs/core';
import { SheetsSelectionsService } from '../../services/selections/selection-manager.service';
import { SheetInterceptorService } from '../../services/sheet-interceptor/sheet-interceptor.service';
-import type { IMoveColumnsMutationParams, IMoveRowsMutationParams } from '../mutations/move-rows-cols.mutation';
import {
MoveColsMutation,
MoveColsMutationUndoFactory,
MoveRowsMutation,
MoveRowsMutationUndoFactory,
} from '../mutations/move-rows-cols.mutation';
-import type { ISetSelectionsOperationParams } from '../operations/selection.operation';
import { SetSelectionsOperation } from '../operations/selection.operation';
-import type { ISelectionWithStyle } from '../../basics';
-import { columnAcrossMergedCell, rowAcrossMergedCell } from './utils/merged-cell-util';
import { alignToMergedCellsBorders, getPrimaryForRange } from './utils/selection-utils';
import { getSheetCommandTarget } from './utils/target-util';
+import type { ISelectionWithStyle } from '../../basics';
+import type { IMoveColumnsMutationParams, IMoveRowsMutationParams } from '../mutations/move-rows-cols.mutation';
+import type { ISetSelectionsOperationParams } from '../operations/selection.operation';
export interface IMoveRowsCommandParams {
unitId?: string;
@@ -51,6 +50,14 @@ export interface IMoveRowsCommandParams {
toRange: IRange;
}
+function rowAcrossMergedCell(row: number, worksheet: Worksheet): boolean {
+ return worksheet.getMergeData().some((mergedCell) => mergedCell.startRow < row && row <= mergedCell.endRow);
+}
+
+function columnAcrossMergedCell(col: number, worksheet: Worksheet): boolean {
+ return worksheet.getMergeData().some((mergedCell) => mergedCell.startColumn < col && col <= mergedCell.endColumn);
+}
+
export const MoveRowsCommandId = 'sheet.command.move-rows' as const;
/**
* Command to move the selected rows (must currently selected) to the specified row.
diff --git a/packages/sheets/src/commands/commands/set-border-command.ts b/packages/sheets/src/commands/commands/set-border-command.ts
index d7f58aded7..c875ec9356 100644
--- a/packages/sheets/src/commands/commands/set-border-command.ts
+++ b/packages/sheets/src/commands/commands/set-border-command.ts
@@ -14,6 +14,15 @@
* limitations under the License.
*/
+import {
+ BorderType,
+ CommandType,
+ ICommandService,
+ IUndoRedoService,
+ IUniverInstanceService,
+ ObjectMatrix,
+ Tools,
+} from '@univerjs/core';
import type {
BorderStyleTypes,
IAccessor,
@@ -24,22 +33,12 @@ import type {
IRange,
IStyleData,
} from '@univerjs/core';
-import {
- BorderType,
- CommandType,
- ICommandService,
- IUndoRedoService,
- IUniverInstanceService,
- ObjectMatrix,
- Rectangle,
- Tools,
-} from '@univerjs/core';
import { BorderStyleManagerService, type IBorderInfo } from '../../services/border-style-manager.service';
import { SheetsSelectionsService } from '../../services/selections/selection-manager.service';
-import type { ISetRangeValuesMutationParams } from '../mutations/set-range-values.mutation';
import { SetRangeValuesMutation, SetRangeValuesUndoMutationFactory } from '../mutations/set-range-values.mutation';
import { getSheetCommandTarget } from './utils/target-util';
+import type { ISetRangeValuesMutationParams } from '../mutations/set-range-values.mutation';
function forEach(range: IRange, action: (row: number, column: number) => void): void {
const { startRow, startColumn, endRow, endColumn } = range;
@@ -147,7 +146,6 @@ export const SetBorderCommand: ICommand = {
const { worksheet, unitId, subUnitId } = target;
const selections = selectionManagerService.getCurrentSelections()?.map((s) => s.range);
- const mergeData = worksheet.getConfig().mergeData;
if (!selections?.length) {
return false;
}
@@ -242,27 +240,10 @@ export const SetBorderCommand: ICommand = {
},
};
- const hasMerge = (row: number, column: number): IRange | null => {
- let res: IRange | null = null;
- mergeData.forEach((merge) => {
- if (
- Rectangle.intersects(merge, {
- startColumn: column,
- endColumn: column,
- startRow: row,
- endRow: row,
- })
- ) {
- res = merge;
- }
- });
- return res;
- };
-
function setBorderStyle(range: IRange, defaultStyle: IBorderData, reserve?: boolean) {
if (range.startRow < 0 || range.startColumn < 0) return;
forEach(range, (row, column) => {
- const rectangle = hasMerge(row, column);
+ const rectangle = worksheet.getMergedCell(row, column);
let bdStyle = defaultStyle;
@@ -338,7 +319,7 @@ export const SetBorderCommand: ICommand = {
// inner vertical border
if (vertical) {
forEach(range, (row, column) => {
- const rectangle = hasMerge(row, column);
+ const rectangle = worksheet.getMergedCell(row, column);
if (rectangle) {
if (rectangle.endColumn !== range.endColumn) {
const style = mr.getValue(rectangle.startRow, rectangle.startColumn)?.s as IStyleData;
@@ -389,7 +370,7 @@ export const SetBorderCommand: ICommand = {
// inner horizontal border
if (horizontal) {
forEach(range, (row, column) => {
- const rectangle = hasMerge(row, column);
+ const rectangle = worksheet.getMergedCell(row, column);
if (rectangle) {
if (rectangle.endRow !== range.endRow) {
const style = mr.getValue(rectangle.startRow, rectangle.startColumn)?.s as IStyleData;
@@ -470,7 +451,7 @@ export const SetBorderCommand: ICommand = {
setBorderStyle(range, { bc_tr: null }, true);
forEach(range, (row, column) => {
- const rectangle = hasMerge(row, column);
+ const rectangle = worksheet.getMergedCell(row, column);
if (rectangle) {
// Clear the right border of all columns except the last column
if (rectangle.endColumn !== range.endColumn) {
diff --git a/packages/sheets/src/commands/commands/utils/merged-cell-util.ts b/packages/sheets/src/commands/commands/utils/merged-cell-util.ts
deleted file mode 100644
index 73a90de9a5..0000000000
--- a/packages/sheets/src/commands/commands/utils/merged-cell-util.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-/**
- * Copyright 2023-present DreamNum Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import type { Worksheet } from '@univerjs/core';
-
-/**
- * @param row after this row
- */
-export function rowAcrossMergedCell(row: number, worksheet: Worksheet): boolean {
- return worksheet.getMergeData().some((mergedCell) => mergedCell.startRow < row && row <= mergedCell.endRow);
-}
-
-export function columnAcrossMergedCell(col: number, worksheet: Worksheet): boolean {
- return worksheet.getMergeData().some((mergedCell) => mergedCell.startColumn < col && col <= mergedCell.endColumn);
-}
diff --git a/packages/sheets/src/commands/mutations/add-worksheet-merge.mutation.ts b/packages/sheets/src/commands/mutations/add-worksheet-merge.mutation.ts
index 3c9e24f387..4191238b6e 100644
--- a/packages/sheets/src/commands/mutations/add-worksheet-merge.mutation.ts
+++ b/packages/sheets/src/commands/mutations/add-worksheet-merge.mutation.ts
@@ -14,8 +14,8 @@
* limitations under the License.
*/
-import type { IAccessor, IMutation } from '@univerjs/core';
import { CommandType, IUniverInstanceService } from '@univerjs/core';
+import type { IAccessor, IMutation } from '@univerjs/core';
import type {
IAddWorksheetMergeMutationParams,
@@ -60,6 +60,7 @@ export const AddWorksheetMergeMutation: IMutation<IAddWorksheetMergeMutationPara
for (let i = 0; i < mergeAppendData.length; i++) {
mergeConfigData.push(mergeAppendData[i]);
}
+ worksheet.getSpanModel().rebuild(mergeConfigData);
return true;
},
diff --git a/packages/sheets/src/commands/mutations/remove-worksheet-merge.mutation.ts b/packages/sheets/src/commands/mutations/remove-worksheet-merge.mutation.ts
index 3026682bdd..2b6a552674 100644
--- a/packages/sheets/src/commands/mutations/remove-worksheet-merge.mutation.ts
+++ b/packages/sheets/src/commands/mutations/remove-worksheet-merge.mutation.ts
@@ -14,8 +14,8 @@
* limitations under the License.
*/
-import type { IAccessor, IMutation } from '@univerjs/core';
import { CommandType, IUniverInstanceService, Rectangle } from '@univerjs/core';
+import type { IAccessor, IMutation } from '@univerjs/core';
import type {
IAddWorksheetMergeMutationParams,
@@ -83,6 +83,8 @@ export const RemoveWorksheetMergeMutation: IMutation<IRemoveWorksheetMergeMutati
}
}
}
+ // update merge data cache
+ worksheet.getSpanModel().rebuild(mergeConfigData);
return true;
},
};
diff --git a/packages/sheets/src/controllers/merge-cell.controller.ts b/packages/sheets/src/controllers/merge-cell.controller.ts
index efcc1f384e..ac4cf3acc3 100644
--- a/packages/sheets/src/controllers/merge-cell.controller.ts
+++ b/packages/sheets/src/controllers/merge-cell.controller.ts
@@ -14,7 +14,6 @@
* limitations under the License.
*/
-import type { ICommandInfo, IMutationInfo, IRange, Workbook } from '@univerjs/core';
import {
createInterceptorKey,
Dimension,
@@ -31,51 +30,52 @@ import {
Tools,
UniverInstanceType,
} from '@univerjs/core';
+import type { ICommandInfo, IMutationInfo, IRange, Workbook } from '@univerjs/core';
-import type {
- IAddWorksheetMergeMutationParams,
- IInsertColMutationParams,
- IRemoveColMutationParams,
- IRemoveRowsMutationParams,
- IRemoveWorksheetMergeMutationParams,
-} from '../basics/interfaces/mutation-interface';
import { ClearSelectionAllCommand } from '../commands/commands/clear-selection-all.command';
import { ClearSelectionFormatCommand } from '../commands/commands/clear-selection-format.command';
-import type { IDeleteRangeMoveLeftCommandParams } from '../commands/commands/delete-range-move-left.command';
import { DeleteRangeMoveLeftCommand } from '../commands/commands/delete-range-move-left.command';
-import type { IDeleteRangeMoveUpCommandParams } from '../commands/commands/delete-range-move-up.command';
import { DeleteRangeMoveUpCommand } from '../commands/commands/delete-range-move-up.command';
-import type { InsertRangeMoveDownCommandParams } from '../commands/commands/insert-range-move-down.command';
import { InsertRangeMoveDownCommand } from '../commands/commands/insert-range-move-down.command';
-import type { InsertRangeMoveRightCommandParams } from '../commands/commands/insert-range-move-right.command';
import { InsertRangeMoveRightCommand } from '../commands/commands/insert-range-move-right.command';
-import type { IInsertColCommandParams, IInsertRowCommandParams } from '../commands/commands/insert-row-col.command';
import { InsertColCommand, InsertRowCommand } from '../commands/commands/insert-row-col.command';
-import type { IMoveRangeCommandParams } from '../commands/commands/move-range.command';
import { MoveRangeCommand } from '../commands/commands/move-range.command';
import { RemoveColCommand, RemoveRowCommand } from '../commands/commands/remove-row-col.command';
-import type { ISetWorksheetActivateCommandParams } from '../commands/commands/set-worksheet-activate.command';
import { SetWorksheetActivateCommand } from '../commands/commands/set-worksheet-activate.command';
+import { getSheetCommandTarget } from '../commands/commands/utils/target-util';
import {
AddMergeUndoMutationFactory,
AddWorksheetMergeMutation,
} from '../commands/mutations/add-worksheet-merge.mutation';
+import { InsertColMutation, InsertRowMutation } from '../commands/mutations/insert-row-col.mutation';
+import { MoveColsMutation, MoveRowsMutation } from '../commands/mutations/move-rows-cols.mutation';
+import { RemoveColMutation, RemoveRowMutation } from '../commands/mutations/remove-row-col.mutation';
import {
RemoveMergeUndoMutationFactory,
RemoveWorksheetMergeMutation,
} from '../commands/mutations/remove-worksheet-merge.mutation';
import { RefRangeService } from '../services/ref-range/ref-range.service';
-import type { EffectRefRangeParams } from '../services/ref-range/type';
import { EffectRefRangId } from '../services/ref-range/type';
import { handleMoveCols, handleMoveRows, runRefRangeMutations } from '../services/ref-range/util';
import { SheetsSelectionsService } from '../services/selections/selection-manager.service';
import { SheetInterceptorService } from '../services/sheet-interceptor/sheet-interceptor.service';
-import type { IMoveRowsMutationParams } from '../commands/mutations/move-rows-cols.mutation';
-import { MoveColsMutation, MoveRowsMutation } from '../commands/mutations/move-rows-cols.mutation';
-import { InsertColMutation, InsertRowMutation } from '../commands/mutations/insert-row-col.mutation';
-import { RemoveColMutation, RemoveRowMutation } from '../commands/mutations/remove-row-col.mutation';
+import type {
+ IAddWorksheetMergeMutationParams,
+ IInsertColMutationParams,
+ IRemoveColMutationParams,
+ IRemoveRowsMutationParams,
+ IRemoveWorksheetMergeMutationParams,
+} from '../basics/interfaces/mutation-interface';
+import type { IDeleteRangeMoveLeftCommandParams } from '../commands/commands/delete-range-move-left.command';
+import type { IDeleteRangeMoveUpCommandParams } from '../commands/commands/delete-range-move-up.command';
+import type { InsertRangeMoveDownCommandParams } from '../commands/commands/insert-range-move-down.command';
+import type { InsertRangeMoveRightCommandParams } from '../commands/commands/insert-range-move-right.command';
+import type { IInsertColCommandParams, IInsertRowCommandParams } from '../commands/commands/insert-row-col.command';
+import type { IMoveRangeCommandParams } from '../commands/commands/move-range.command';
import type { IMoveColsCommandParams, IMoveRowsCommandParams } from '../commands/commands/move-rows-cols.command';
-import { getSheetCommandTarget } from '../commands/commands/utils/target-util';
+import type { ISetWorksheetActivateCommandParams } from '../commands/commands/set-worksheet-activate.command';
+import type { IMoveRowsMutationParams } from '../commands/mutations/move-rows-cols.mutation';
+import type { EffectRefRangeParams } from '../services/ref-range/type';
const mutationIdByRowCol = [InsertColMutation.id, InsertRowMutation.id, RemoveColMutation.id, RemoveRowMutation.id];
const mutationIdArrByMove = [MoveRowsMutation.id, MoveColsMutation.id];
@@ -1066,19 +1066,13 @@ export class MergeCellController extends Disposable {
subUnitId,
ranges: removeMergeData,
};
- const undoRemoveMergeParams: IAddWorksheetMergeMutationParams = RemoveMergeUndoMutationFactory(
- this._injector,
- removeMergeParams
- );
+ const undoRemoveMergeParams: IAddWorksheetMergeMutationParams = RemoveMergeUndoMutationFactory(this._injector, removeMergeParams);
const addMergeParams: IAddWorksheetMergeMutationParams = {
unitId,
subUnitId,
ranges: addMergeData,
};
- const undoAddMergeParams: IRemoveWorksheetMergeMutationParams = AddMergeUndoMutationFactory(
- this._injector,
- addMergeParams
- );
+ const undoAddMergeParams: IRemoveWorksheetMergeMutationParams = AddMergeUndoMutationFactory(this._injector, addMergeParams);
return {
redos: [
{ id: RemoveWorksheetMergeMutation.id, params: removeMergeParams },
@@ -1151,7 +1145,7 @@ export class MergeCellController extends Disposable {
adjustedMergedCells.push({ startRow, endRow, startColumn, endColumn, rangeType });
}
});
- worksheet.getConfig().mergeData = adjustedMergedCells;
+ worksheet.setMergeData(adjustedMergedCells);
this.disposableCollection.dispose();
const { unitId, subUnitId } = command.params as IMoveRowsMutationParams;
@@ -1217,7 +1211,7 @@ export class MergeCellController extends Disposable {
}
});
- worksheet.getConfig().mergeData = adjustedMergedCells;
+ worksheet.setMergeData(adjustedMergedCells);
this.disposableCollection.dispose();
const { unitId, subUnitId } = command.params as IMoveRowsMutationParams;