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.
TypeScript boardcollaborationdocdocxexceloffce365officepdfpptpptxpresentationsdksheetslidesspreadsheetuniverwordwordprocessorworkspacexlsx
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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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 contentdiff --git a/packages/core/src/sheets/worksheet.ts b/packages/core/src/sheets/worksheet.tsindex 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 rangeconst 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.tsindex 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-constlet { 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.tsindex 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-functionborder?.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.tsindex 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.tsindex 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.tsindex 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.tsindex 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, SHEEoverride 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 rowIndexdiff --git a/packages/engine-render/src/components/sheets/sheet-skeleton.ts b/packages/engine-render/src/components/sheets/sheet-skeleton.tsindex 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 heightprivate _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 currentif (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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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, complexityprivate _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.tsindex 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 IRenderModconst 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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, startColuconst 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 rangeconst returnCellMatrix = new ObjectMatrix<IMatrixWithSpanInfo>();diff --git a/packages/sheets/src/basics/selection.ts b/packages/sheets/src/basics/selection.tsindex 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 Coordinatediff --git a/packages/sheets/src/commands/commands/move-rows-cols.command.ts b/packages/sheets/src/commands/commands/move-rows-cols.command.tsindex 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.tsindex 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 borderif (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 borderif (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 columnif (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.tsdeleted file mode 100644index 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.tsindex 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<IAddWorksheetMergeMutationParafor (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.tsindex 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.tsindex 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;