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): optimize incremental scroll rendering (#7207)
Univer1a6131305533
diff --git a/packages/engine-render/src/__tests__/engine-scene-viewport.spec.ts b/packages/engine-render/src/__tests__/engine-scene-viewport.spec.tsindex e314bff347..10dd5b75c1 100644--- a/packages/engine-render/src/__tests__/engine-scene-viewport.spec.ts+++ b/packages/engine-render/src/__tests__/engine-scene-viewport.spec.ts@@ -865,4 +865,29 @@ describe('engine scene viewport extra', () => {scene.dispose();engine.dispose();});++ it('expands cache diff strips across both axes to avoid exposing blank cache gaps', () => {+ const { engine, scene, viewport } = createFixture();+ viewport.bufferEdgeX = 10;+ viewport.bufferEdgeY = 20;++ const verticalDiff = (viewport as any)._calcDiffCacheBound(+ { left: 0, top: 0, right: 100, bottom: 100 },+ { left: 0, top: 50, right: 100, bottom: 150 }+ );+ expect(verticalDiff).toEqual([+ { left: -10, top: 80, right: 110, bottom: 170 },+ ]);++ const horizontalDiff = (viewport as any)._calcDiffCacheBound(+ { left: 0, top: 0, right: 100, bottom: 100 },+ { left: 50, top: 0, right: 150, bottom: 100 }+ );+ expect(horizontalDiff).toEqual([+ { left: 90, top: -20, right: 160, bottom: 120 },+ ]);++ scene.dispose();+ engine.dispose();+ });});diff --git a/packages/engine-render/src/components/extension.ts b/packages/engine-render/src/components/extension.tsindex 9e591618b6..87a72db732 100644--- a/packages/engine-render/src/components/extension.ts+++ b/packages/engine-render/src/components/extension.ts@@ -34,6 +34,8 @@ export interface IDrawInfo {viewRanges: IRange[];viewportKey: string;checkOutOfViewBound?: boolean;+ fontRenderRanges?: IRange[];+ hasMergeData?: boolean;viewBound?: IBoundRectNoAngle;}export class ComponentExtension<T, U, V> {diff --git a/packages/engine-render/src/components/sheets/__tests__/spreadsheet.integration.spec.ts b/packages/engine-render/src/components/sheets/__tests__/spreadsheet.integration.spec.tsindex 4ec5bbeebf..a802181bda 100644--- a/packages/engine-render/src/components/sheets/__tests__/spreadsheet.integration.spec.ts+++ b/packages/engine-render/src/components/sheets/__tests__/spreadsheet.integration.spec.ts@@ -20,6 +20,7 @@ import {BooleanNumber,BorderStyleTypes,createSheetGapTestConfig,+ HorizontalAlign,ILogService,IUniverInstanceService,LocaleType,@@ -28,10 +29,12 @@ import {RANGE_TYPE,Univer,UniverInstanceType,+ VerticalAlign,WrapStrategy,} from '@univerjs/core';import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';import { setupRenderTestEnv } from '../../../__tests__/render-test-utils';+import { FontCache } from '../../../basics';import { Vector2 } from '../../../basics/vector2';import { Canvas } from '../../../canvas';import { Engine } from '../../../engine';@@ -512,8 +515,191 @@ describe('spreadsheet integration', () => {noSkeletonSpreadsheet.dispose();});+ it('skips merge gridline cleanup during merge-free drawing', () => {+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;+ const context = mainCanvas.getContext() as any;+ const extensionDraw = vi.fn();+ vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);+ const getMergeRangesSpy = vi.spyOn(skeleton, 'getCurrentRowColumnSegmentMergeData');+ vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([{+ uKey: 'MockSheetExtension',+ draw: extensionDraw,+ }]);++ spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas));++ expect(getMergeRangesSpy).not.toHaveBeenCalled();+ expect(extensionDraw.mock.calls.at(-1)?.[4].hasMergeData).toBe(false);+ });++ it('skips sparse extensions with no matching cell data during merge-free incremental drawing', () => {+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;+ const context = mainCanvas.getContext() as any;+ const sparseDraw = vi.fn();+ const regularDraw = vi.fn();++ vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);+ vi.spyOn(skeleton.worksheet, 'getCell').mockReturnValue(undefined);+ vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([+ {+ draw: sparseDraw,+ uKey: 'DefaultCustomExtension',+ },+ {+ draw: regularDraw,+ uKey: 'RegularExtension',+ },+ ]);++ (spreadsheet as any)._refreshIncrementalState = true;+ spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas, {+ diffBounds: [createBound(100, 60, 220, 140)],+ diffCacheBounds: [createBound(100, 60, 220, 140)],+ }));+ (spreadsheet as any)._refreshIncrementalState = false;++ expect(sparseDraw).not.toHaveBeenCalled();+ expect(regularDraw).toHaveBeenCalledOnce();+ });++ it('does not skip conditional-formatting render extensions during sparse scans', () => {+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;+ const context = mainCanvas.getContext() as any;+ const dataBarDraw = vi.fn();+ const iconDraw = vi.fn();+ const markerDraw = vi.fn();++ vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);+ vi.spyOn(skeleton.worksheet, 'getCell').mockReturnValue(undefined);+ vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([+ {+ draw: dataBarDraw,+ uKey: 'sheet-conditional-rule-data-bar',+ },+ {+ draw: iconDraw,+ uKey: 'sheet-conditional-rule-icon',+ },+ {+ draw: markerDraw,+ uKey: 'DefaultMarkerExtension',+ },+ ]);++ (spreadsheet as any)._refreshIncrementalState = true;+ spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas, {+ diffBounds: [createBound(100, 60, 220, 140)],+ diffCacheBounds: [createBound(100, 60, 220, 140)],+ }));+ (spreadsheet as any)._refreshIncrementalState = false;++ expect(dataBarDraw).toHaveBeenCalledOnce();+ expect(iconDraw).toHaveBeenCalledOnce();+ expect(markerDraw).not.toHaveBeenCalled();+ });++ it('does not scan sparse extension features when no sparse extension is registered', () => {+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;+ const context = mainCanvas.getContext() as any;+ const regularDraw = vi.fn();+ const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');++ vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);+ vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([+ {+ draw: regularDraw,+ uKey: 'RegularExtension',+ },+ ]);++ (spreadsheet as any)._refreshIncrementalState = true;+ spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas, {+ diffBounds: [createBound(100, 60, 220, 140)],+ diffCacheBounds: [createBound(100, 60, 220, 140)],+ }));+ (spreadsheet as any)._refreshIncrementalState = false;++ expect(regularDraw).toHaveBeenCalledOnce();+ expect(getCellSpy).not.toHaveBeenCalled();+ });++ it('narrows sparse extension diff ranges to matching cells during merge-free incremental drawing', () => {+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;+ const context = mainCanvas.getContext() as any;+ const markerDraw = vi.fn();++ vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);+ vi.spyOn(skeleton.worksheet, 'getCell').mockImplementation((row: number, col: number) => (+ row === 2 && col === 1 ? { markers: { tr: { color: '#ff0000', size: 4 } } } : undefined+ ));+ vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([+ {+ draw: markerDraw,+ uKey: 'DefaultMarkerExtension',+ },+ ]);++ (spreadsheet as any)._refreshIncrementalState = true;+ spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas, {+ diffBounds: [createBound(48, 48, 240, 120)],+ diffCacheBounds: [createBound(48, 48, 240, 120)],+ }));+ (spreadsheet as any)._refreshIncrementalState = false;++ expect(markerDraw).toHaveBeenCalledOnce();+ expect(markerDraw.mock.calls[0][3]).toEqual([{+ startRow: 2,+ endRow: 2,+ startColumn: 1,+ endColumn: 1,+ }]);+ });++ it('reuses style cache cell data when scanning sparse extension features', () => {+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;+ const context = mainCanvas.getContext() as any;+ const markerDraw = vi.fn();+ const diffBound = createBound(48, 48, 240, 120);+ const diffRange = skeleton.getRangeByViewBound(diffBound);+ const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');++ vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);+ for (let row = diffRange.startRow; row <= diffRange.endRow; row++) {+ for (let col = diffRange.startColumn; col <= diffRange.endColumn; col++) {+ skeleton.stylesCache.fontMatrix.setValue(row, col, {+ cellData: row === 2 && col === 1+ ? { markers: { tr: { color: '#ff0000', size: 4 } } }+ : { v: `${row}-${col}` },+ } as any);+ }+ }+ vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([+ {+ draw: markerDraw,+ uKey: 'DefaultMarkerExtension',+ },+ ]);++ (spreadsheet as any)._refreshIncrementalState = true;+ spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas, {+ diffBounds: [diffBound],+ diffCacheBounds: [diffBound],+ }));+ (spreadsheet as any)._refreshIncrementalState = false;++ expect(getCellSpy).not.toHaveBeenCalled();+ expect(markerDraw).toHaveBeenCalledOnce();+ expect(markerDraw.mock.calls[0][3]).toEqual([{+ startRow: 2,+ endRow: 2,+ startColumn: 1,+ endColumn: 1,+ }]);+ });+it('skips style cache cell visits when scrolling inside the existing cache area', () => {const { skeleton, scene, cacheCanvas } = fixture;+ vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);const styleCellSpy = vi.spyOn(skeleton as any, '_setStylesCacheForOneCell');const viewportInfo = createViewportInfo(scene, cacheCanvas, {diffBounds: [createBound(100, 60, 220, 140)],@@ -531,6 +717,178 @@ describe('spreadsheet integration', () => {expect(skeleton.rowColumnSegment).toEqual(skeleton.getCacheRangeByViewport(viewportInfo));});+ it('skips merge lookups for one-cell style cache when merge data is absent', () => {+ const { skeleton } = fixture;+ const mergeInfoSpy = vi.spyOn(skeleton.worksheet, 'getCellInfoInMergeData');++ (skeleton as any)._setStylesCacheForOneCell(0, 0, {+ cacheItem: { bg: true, border: true },+ hasMergeData: false,+ });++ expect(mergeInfoSpy).not.toHaveBeenCalled();+ });++ it('reuses row visibility from the style cache row scan', () => {+ const { skeleton, scene, cacheCanvas } = fixture;+ const getRowVisibleSpy = vi.spyOn(skeleton.worksheet, 'getRowVisible');+ const viewportInfo = createViewportInfo(scene, cacheCanvas);++ skeleton.setStylesCache(viewportInfo);++ const visibleRange = skeleton.rowColumnSegment;+ const visibleRowCount = visibleRange.endRow - visibleRange.startRow + 1;+ expect(getRowVisibleSpy.mock.calls.length).toBeLessThan(visibleRowCount * 3);+ });++ it('reuses cached overflow-only font styles without reading cell data again', () => {+ const { skeleton } = fixture;+ const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');+ const getStyleSpy = vi.spyOn(skeleton.worksheet, 'getComposedCellStyleByCellData');+ const options = { cacheItem: { bg: false, border: false }, reuseExisting: true };++ (skeleton as any)._setStylesCacheForOneCell(0, 0, options);+ const getCellCalls = getCellSpy.mock.calls.length;+ const getStyleCalls = getStyleSpy.mock.calls.length;++ (skeleton as any)._setStylesCacheForOneCell(0, 0, options);++ expect(getCellSpy.mock.calls.length).toBe(getCellCalls);+ expect(getStyleSpy.mock.calls.length).toBe(getStyleCalls);+ });++ it('reuses fully cached cell styles during incremental scrolling', () => {+ const { skeleton } = fixture;+ const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');+ const getStyleSpy = vi.spyOn(skeleton.worksheet, 'getComposedCellStyleByCellData');++ (skeleton as any)._setStylesCacheForOneCell(0, 0, { cacheItem: { bg: true, border: true } });+ const getCellCalls = getCellSpy.mock.calls.length;+ const getStyleCalls = getStyleSpy.mock.calls.length;++ (skeleton as any)._setStylesCacheForOneCell(0, 0, { cacheItem: { bg: true, border: true }, reuseExisting: true });++ expect(getCellSpy.mock.calls.length).toBe(getCellCalls);+ expect(getStyleSpy.mock.calls.length).toBe(getStyleCalls);+ });++ it('skips overflow boundary scanning when text fits in the current column', () => {+ const { skeleton } = fixture;+ const overflowBoundSpy = vi.spyOn(skeleton as any, '_getOverflowBound');+ const fontCache = {+ cellData: { v: 'A1' },+ fontString: '12px Arial',+ horizontalAlign: HorizontalAlign.LEFT,+ verticalAlign: VerticalAlign.TOP,+ wrapStrategy: WrapStrategy.OVERFLOW,+ } as any;++ const result = (skeleton as any)._calculateOverflowCell(0, 0, fontCache);++ expect(result).toBe(true);+ expect(fontCache.textFitsCurrentCell).toBe(true);+ expect(overflowBoundSpy).not.toHaveBeenCalled();+ });++ it('skips overflow text measurement when the adjacent cell blocks overflow', () => {+ const { skeleton } = fixture;+ const measureSpy = vi.spyOn(FontCache, 'getMeasureText');+ vi.spyOn(skeleton.worksheet, 'getCell').mockImplementation((row: number, col: number) => (+ row === 0 && col === 1 ? { v: 'blocked' } as any : { v: 'long text' } as any+ ));++ const result = (skeleton as any)._calculateOverflowCell(0, 0, {+ cellData: { v: 'this is a very long text that would normally be measured' },+ fontString: '12px Arial',+ horizontalAlign: HorizontalAlign.LEFT,+ verticalAlign: VerticalAlign.TOP,+ wrapStrategy: WrapStrategy.OVERFLOW,+ });++ expect(result).toBe(true);+ expect(measureSpy).not.toHaveBeenCalled();+ });++ it('uses raw adjacent cell data to block overflow without worksheet reads', () => {+ const { skeleton } = fixture;+ const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');+ const measureSpy = vi.spyOn(FontCache, 'getMeasureText');++ const result = (skeleton as any)._calculateOverflowCell(0, 0, {+ cellData: { v: 'this is a very long text that would normally inspect the adjacent cell' },+ fontString: '12px Arial',+ horizontalAlign: HorizontalAlign.LEFT,+ verticalAlign: VerticalAlign.TOP,+ wrapStrategy: WrapStrategy.OVERFLOW,+ });++ expect(result).toBe(true);+ expect(getCellSpy).not.toHaveBeenCalled();+ expect(measureSpy).not.toHaveBeenCalled();+ });++ it('skips merge checks during overflow calculation when the sheet has no merged cells', () => {+ const { skeleton } = fixture;+ const mergeSpy = vi.spyOn(skeleton, 'intersectMergeRange');+ vi.spyOn(skeleton.worksheet, 'getCell').mockImplementation((row: number, col: number) => (+ row === 0 && col === 1 ? { v: 'blocked' } as any : { v: 'long text' } as any+ ));++ const result = (skeleton as any)._calculateOverflowCell(0, 0, {+ cellData: { v: 'this is a very long text that would normally check merge ranges' },+ fontString: '12px Arial',+ horizontalAlign: HorizontalAlign.LEFT,+ verticalAlign: VerticalAlign.TOP,+ wrapStrategy: WrapStrategy.OVERFLOW,+ }, false);++ expect(result).toBe(true);+ expect(mergeSpy).not.toHaveBeenCalled();+ });++ it('skips style cache work for sheet header viewports', () => {+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;+ const context = mainCanvas.getContext();+ const styleCacheSpy = vi.spyOn(skeleton, 'setStylesCache');+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {+ viewportKey: SHEET_VIEWPORT_KEY.VIEW_ROW_TOP,+ });++ spreadsheet.render(context, viewportInfo);++ expect(styleCacheSpy).not.toHaveBeenCalled();+ });++ it('copies the full cache viewport so the first row and column remain visible', () => {+ const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;+ const context = mainCanvas.getContext() as any;+ const applyCacheSpy = vi.spyOn(spreadsheet as any, '_applyCache').mockImplementation(() => {});+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {+ diffBounds: [],+ diffCacheBounds: [],+ isDirty: 0,+ isForceDirty: false,+ viewPortPosition: createBound(10, 20, 410, 220),+ });+ spreadsheet.makeDirty(false);+ spreadsheet.makeForceDirty(false);++ spreadsheet.renderByViewports(context, viewportInfo, skeleton);++ expect(applyCacheSpy).toHaveBeenCalledWith(+ cacheCanvas,+ context,+ 12,+ 8,+ 400 + skeleton.rowHeaderWidthAndMarginLeft,+ 200 + skeleton.columnHeaderHeightAndMarginTop,+ 10,+ 20,+ 400 + skeleton.rowHeaderWidthAndMarginLeft,+ 200 + skeleton.columnHeaderHeightAndMarginTop+ );+ });+it('refreshes cache instead of incremental painting for large scroll jumps', () => {const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;const context = mainCanvas.getContext();@@ -555,6 +913,82 @@ describe('spreadsheet integration', () => {expect(paintSpy).not.toHaveBeenCalled();});+ it('uses backing-store cache size when detecting large scroll jumps', () => {+ const { spreadsheet, skeleton, mainCanvas, scene } = fixture;+ const context = mainCanvas.getContext();+ const cacheCanvas = new Canvas({ width: 700, height: 420, pixelRatio: 1.5 });+ vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);+ context.setTransform(1.5, 0, 0, 1.5, 0, 0);+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {+ diffBounds: [createBound(0, 360, 460, 640)],+ diffCacheBounds: [createBound(0, 360, 460, 640)],+ diffX: 0,+ diffY: -360,+ isDirty: 0,+ isForceDirty: false,+ shouldCacheUpdate: 1,+ });+ spreadsheet.makeDirty(false);+ spreadsheet.makeForceDirty(false);++ const paintSpy = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');+ const refreshSpy = vi.spyOn(spreadsheet, 'refreshCacheCanvas');++ spreadsheet.renderByViewports(context, viewportInfo, skeleton);++ expect(paintSpy).toHaveBeenCalledOnce();+ expect(refreshSpy).not.toHaveBeenCalled();+ cacheCanvas.dispose();+ });++ it('refreshes cache for merged sheets while scrolling to keep merged text visible', () => {+ const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;+ const context = mainCanvas.getContext();+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {+ diffBounds: [createBound(0, 360, 460, 640)],+ diffCacheBounds: [],+ diffX: 0,+ diffY: -48,+ isDirty: 0,+ isForceDirty: false,+ shouldCacheUpdate: 0,+ });+ spreadsheet.makeDirty(false);+ spreadsheet.makeForceDirty(false);++ const paintSpy = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');+ const refreshSpy = vi.spyOn(spreadsheet, 'refreshCacheCanvas');++ spreadsheet.renderByViewports(context, viewportInfo, skeleton);++ expect(refreshSpy).toHaveBeenCalledOnce();+ expect(paintSpy).not.toHaveBeenCalled();+ });++ it('refreshes cache for horizontal cache updates to avoid exposing stale cache edges', () => {+ const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;+ const context = mainCanvas.getContext();+ const viewportInfo = createViewportInfo(scene, cacheCanvas, {+ diffBounds: [createBound(520, 0, 640, 280)],+ diffCacheBounds: [createBound(520, 0, 640, 280)],+ diffX: -80,+ diffY: 0,+ isDirty: 0,+ isForceDirty: false,+ shouldCacheUpdate: 1,+ });+ spreadsheet.makeDirty(false);+ spreadsheet.makeForceDirty(false);++ const paintSpy = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');+ const refreshSpy = vi.spyOn(spreadsheet, 'refreshCacheCanvas');++ spreadsheet.renderByViewports(context, viewportInfo, skeleton);++ expect(refreshSpy).toHaveBeenCalledOnce();+ expect(paintSpy).not.toHaveBeenCalled();+ });+it('draws row and column gap areas using defaults from gapConfig', () => {const { spreadsheet, skeleton, mainCanvas } = fixture;const context = mainCanvas.getContext() as any;diff --git a/packages/engine-render/src/components/sheets/extensions/__tests__/background.spec.ts b/packages/engine-render/src/components/sheets/extensions/__tests__/background.spec.tsindex 4fc03a839d..95c8d85f84 100644--- a/packages/engine-render/src/components/sheets/extensions/__tests__/background.spec.ts+++ b/packages/engine-render/src/components/sheets/extensions/__tests__/background.spec.ts@@ -129,6 +129,135 @@ describe('background extension', () => {expect(bgByMatrix.forValue).toHaveBeenCalled();});+ it('reuses cached background cell positions when drawing backgrounds', () => {+ const extension = new Background();+ const ctx = createCtx();+ const bgMatrix = createBgMatrix([[0, 0, '1']], 99);+ const backgroundPositions = new ObjectMatrix();+ backgroundPositions.setValue(0, 0, createCellInfo());++ const skeleton = {+ worksheet: {+ getMergedCellRange: vi.fn(() => []),+ getRowVisible: vi.fn(() => true),+ getColVisible: vi.fn(() => true),+ getSpanModel: vi.fn(() => ({+ getMergeDataIndex: vi.fn(() => -1),+ })),+ },+ stylesCache: {+ background: { '#ff0000': bgMatrix },+ backgroundPositions,+ },+ rowHeightAccumulation: [20],+ columnWidthAccumulation: [40],+ columnTotalWidth: 40,+ rowTotalHeight: 20,+ getCellByIndexWithNoHeader: vi.fn(() => createCellInfo()),+ getCellWithCoordByIndex: vi.fn(() => createCellInfo()),+ } as any;++ extension.draw(+ ctx,+ { scaleX: 1, scaleY: 1 } as any,+ skeleton,+ [],+ {+ viewRanges: [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }],+ checkOutOfViewBound: true,+ } as any+ );++ expect(skeleton.getCellByIndexWithNoHeader).not.toHaveBeenCalled();+ expect(ctx.fill).toHaveBeenCalled();+ });++ it('skips merge lookups when drawing merge-free backgrounds', () => {+ const extension = new Background();+ const ctx = createCtx();+ const bgMatrix = createBgMatrix([[0, 0, '1']], 99);+ const getMergeDataIndex = vi.fn(() => -1);+ const worksheet = {+ getMergedCellRange: vi.fn(() => []),+ getRowVisible: vi.fn(() => true),+ getColVisible: vi.fn(() => true),+ getSpanModel: vi.fn(() => ({+ getMergeDataIndex,+ })),+ };+ const skeleton = {+ worksheet,+ stylesCache: {+ background: { '#ff0000': bgMatrix },+ backgroundPositions: new ObjectMatrix(),+ },+ rowHeightAccumulation: [20],+ columnWidthAccumulation: [40],+ columnTotalWidth: 40,+ rowTotalHeight: 20,+ getCellByIndexWithNoHeader: vi.fn(() => createCellInfo()),+ getCellWithCoordByIndex: vi.fn(() => createCellInfo()),+ } as any;++ extension.draw(+ ctx,+ { scaleX: 1, scaleY: 1 } as any,+ skeleton,+ [],+ {+ viewRanges: [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }],+ checkOutOfViewBound: true,+ hasMergeData: false,+ } as any+ );++ expect(worksheet.getMergedCellRange).not.toHaveBeenCalled();+ expect(worksheet.getSpanModel).not.toHaveBeenCalled();+ expect(getMergeDataIndex).not.toHaveBeenCalled();+ expect(ctx.fill).toHaveBeenCalled();+ });++ it('uses diff ranges to choose background iteration during incremental drawing', () => {+ const extension = new Background();+ const ctx = createCtx();+ const bgMatrix = createBgMatrix([[1, 1, '1']], 4);++ const skeleton = {+ worksheet: {+ getMergedCellRange: vi.fn(() => []),+ getRowVisible: vi.fn(() => true),+ getColVisible: vi.fn(() => true),+ getSpanModel: vi.fn(() => ({+ getMergeDataIndex: vi.fn(() => -1),+ })),+ },+ stylesCache: {+ background: { '#ff0000': bgMatrix },+ backgroundPositions: new ObjectMatrix(),+ },+ rowHeightAccumulation: [20, 40],+ columnWidthAccumulation: [40, 80],+ columnTotalWidth: 80,+ rowTotalHeight: 40,+ getCellByIndexWithNoHeader: vi.fn(() => createCellInfo()),+ getCellWithCoordByIndex: vi.fn(() => createCellInfo()),+ } as any;++ extension.draw(+ ctx,+ { scaleX: 1, scaleY: 1 } as any,+ skeleton,+ [{ startRow: 1, endRow: 1, startColumn: 1, endColumn: 1 }],+ {+ viewRanges: [{ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 }],+ checkOutOfViewBound: true,+ } as any+ );++ expect(bgMatrix.forValue).not.toHaveBeenCalled();+ expect(bgMatrix.getValue).toHaveBeenCalledWith(1, 1);+ });+it('draws merged cell backgrounds and handles early draw exits', () => {const extension = new Background();const ctx = createCtx();@@ -201,6 +330,14 @@ describe('background extension', () => {const rowHidden = extension.renderBGByCell(bgContext, 0, 0);expect(rowHidden).toBe(true);+ skeleton.worksheet.getRowVisible = vi.fn(() => true);+ bgContext.viewRanges = [{ startRow: 10, endRow: 10, startColumn: 10, endColumn: 10 }];+ bgContext.skipRenderRangeCheck = true;+ const skippedRangeCheck = extension.renderBGByCell(bgContext, 0, 0);+ expect(skippedRangeCheck).toBeUndefined();+ expect(rect).toHaveBeenCalled();+ bgContext.skipRenderRangeCheck = false;+bgContext.cellInfo = createCellInfo({isMergedMainCell: true,mergeInfo: {diff --git a/packages/engine-render/src/components/sheets/extensions/__tests__/font.spec.ts b/packages/engine-render/src/components/sheets/extensions/__tests__/font.spec.tsindex 8335b7272a..fb3327c1e2 100644--- a/packages/engine-render/src/components/sheets/extensions/__tests__/font.spec.ts+++ b/packages/engine-render/src/components/sheets/extensions/__tests__/font.spec.ts@@ -32,6 +32,7 @@ function createCtx() {rectByPrecision: vi.fn(),drawImage: vi.fn(),fillRectByPrecision: vi.fn(),+ fillText: vi.fn(),getScale: vi.fn(() => ({ scaleX: 1, scaleY: 1 })),} as any;}@@ -86,6 +87,7 @@ function createSpreadsheetSkeleton() {getRowVisible: vi.fn(() => true),getColVisible: vi.fn(() => true),getCell: vi.fn(() => ({ v: 'A', t: CellValueType.STRING })),+ getMergeData: vi.fn(() => []),getSpanModel: vi.fn(() => ({getMergeDataIndex: vi.fn(() => -1),})),@@ -211,6 +213,7 @@ describe('font extension', () => {it('covers text render alignment and wrap branches', () => {const drawWithSpy = vi.spyOn(Text as any, 'drawWith').mockImplementation((..._args: any[]) => undefined);+ const drawPlainSpy = vi.spyOn(Text as any, 'drawPlainWith').mockImplementation((..._args: any[]) => undefined);const font = new Font() as any;const ctx = createCtx();const overflow = new ObjectMatrix<any>();@@ -243,20 +246,40 @@ describe('font extension', () => {cellData: { v: true, t: CellValueType.BOOLEAN },});font._renderText(ctx, 0, 0, renderFontCtx, overflow);- expect(drawWithSpy).toHaveBeenLastCalledWith(+ expect(drawPlainSpy).toHaveBeenLastCalledWith(ctx,expect.objectContaining({hAlign: HorizontalAlign.CENTER,+ text: 'TRUE',+ warp: false,+ })+ );++ renderFontCtx.fontCache = createFontCache({+ horizontalAlign: HorizontalAlign.UNSPECIFIED,+ resolvedHorizontalAlign: HorizontalAlign.LEFT,+ displayText: 'cached text',+ wrapStrategy: WrapStrategy.OVERFLOW,+ cellData: { v: 123, t: CellValueType.NUMBER },+ });+ font._renderText(ctx, 0, 0, renderFontCtx, overflow);+ expect(drawPlainSpy).toHaveBeenLastCalledWith(+ ctx,+ expect.objectContaining({+ hAlign: HorizontalAlign.LEFT,+ text: 'cached text',warp: false,}));const before = drawWithSpy.mock.calls.length;+ const beforePlain = drawPlainSpy.mock.calls.length;renderFontCtx.fontCache = createFontCache({cellData: { v: null, t: CellValueType.STRING },});font._renderText(ctx, 0, 0, renderFontCtx, overflow);expect(drawWithSpy.mock.calls.length).toBe(before);+ expect(drawPlainSpy.mock.calls.length).toBe(beforePlain);});it('covers documents render branches and missing documents error', () => {@@ -601,6 +624,151 @@ describe('font extension', () => {expect(ctx.restore).toHaveBeenCalled();});+ it('does not read live cell data for plain cached font cells', () => {+ const font = new Font() as any;+ const ctx = createCtx();+ const spreadsheetSkeleton = createSpreadsheetSkeleton();+ const fontMatrix = new ObjectMatrix<any>();+ fontMatrix.setValue(0, 0, createFontCache({+ cellData: { v: 'text', t: CellValueType.STRING },+ }));+ const getCellSpy = vi.spyOn(spreadsheetSkeleton.worksheet, 'getCell');+ vi.spyOn(font, '_renderText').mockImplementation(() => undefined);++ const result = font._renderFontEachCell({+ ctx,+ scale: 1,+ columnTotalWidth: 120,+ rowTotalHeight: 60,+ viewRanges: [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }],+ checkOutOfViewBound: true,+ diffRanges: [],+ spreadsheetSkeleton,+ cellInfo: createCellInfo(),+ } as any, 0, 0, fontMatrix);++ expect(result).toBe(false);+ expect(getCellSpy).not.toHaveBeenCalled();+ });++ it('draws fitting plain text without clipping', () => {+ const font = new Font() as any;+ const ctx = createCtx();+ const spreadsheetSkeleton = createSpreadsheetSkeleton();+ const fontMatrix = new ObjectMatrix<any>();+ fontMatrix.setValue(0, 0, createFontCache({+ cellData: { v: 123, t: CellValueType.NUMBER },+ displayText: 'cached fit',+ resolvedHorizontalAlign: HorizontalAlign.LEFT,+ textFitsCurrentCell: true,+ }));+ const drawPlainSpy = vi.spyOn(Text, 'drawPlainWith').mockImplementation(() => 10);+ const clipSpy = vi.spyOn(font, '_clipByRenderBounds').mockImplementation(() => undefined);+ const renderTextSpy = vi.spyOn(font, '_renderText').mockImplementation(() => undefined);++ const result = font._renderFontEachCell({+ ctx,+ scale: 1,+ columnTotalWidth: 120,+ rowTotalHeight: 60,+ viewRanges: [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }],+ checkOutOfViewBound: true,+ diffRanges: [],+ spreadsheetSkeleton,+ cellInfo: createCellInfo(),+ } as any, 0, 0, fontMatrix);++ expect(result).toBe(false);+ expect(drawPlainSpy).toHaveBeenCalledOnce();+ expect(drawPlainSpy).toHaveBeenCalledWith(+ ctx,+ expect.objectContaining({+ text: 'cached fit',+ hAlign: HorizontalAlign.LEFT,+ })+ );+ expect(clipSpy).not.toHaveBeenCalled();+ expect(renderTextSpy).not.toHaveBeenCalled();+ expect(ctx.save).not.toHaveBeenCalled();+ });++ it('checks live cell data for cached font render extensions', () => {+ const font = new Font() as any;+ const ctx = createCtx();+ const spreadsheetSkeleton = createSpreadsheetSkeleton();+ const fontMatrix = new ObjectMatrix<any>();+ fontMatrix.setValue(0, 0, createFontCache({+ cellData: { v: 'text', t: CellValueType.STRING, fontRenderExtension: {} },+ }));+ vi.spyOn(spreadsheetSkeleton.worksheet, 'getCell').mockReturnValue({+ v: 'text',+ t: CellValueType.STRING,+ fontRenderExtension: { isSkip: true },+ } as any);+ const renderTextSpy = vi.spyOn(font, '_renderText').mockImplementation(() => undefined);++ const result = font._renderFontEachCell({+ ctx,+ scale: 1,+ columnTotalWidth: 120,+ rowTotalHeight: 60,+ viewRanges: [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }],+ checkOutOfViewBound: true,+ diffRanges: [],+ spreadsheetSkeleton,+ cellInfo: createCellInfo(),+ } as any, 0, 0, fontMatrix);++ expect(result).toBe(true);+ expect(renderTextSpy).not.toHaveBeenCalled();+ });++ it('skips coordinate calculation for cells without font cache', () => {+ const font = new Font() as any;+ const ctx = createCtx();+ const spreadsheetSkeleton = createSpreadsheetSkeleton();+ const fontMatrix = new ObjectMatrix<any>();+ fontMatrix.setValue(0, 0, createFontCache());+ spreadsheetSkeleton.stylesCache = { fontMatrix };+ spreadsheetSkeleton.columnTotalWidth = 120;+ spreadsheetSkeleton.rowTotalHeight = 60;+ const renderCellSpy = vi.spyOn(font, '_renderFontEachCell').mockReturnValue(true);++ font.draw(ctx, { scaleX: 1, scaleY: 1 } as any, spreadsheetSkeleton, [], {+ viewRanges: [{ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 }],+ checkOutOfViewBound: true,+ viewportKey: 'viewMain',+ } as any);++ expect(spreadsheetSkeleton.getCellWithCoordByIndex).toHaveBeenCalledOnce();+ expect(spreadsheetSkeleton.getCellWithCoordByIndex).toHaveBeenCalledWith(0, 0, false);+ expect(renderCellSpy).toHaveBeenCalledOnce();+ });++ it('skips merge lookup work when the sheet has no merged cells', () => {+ const font = new Font() as any;+ const ctx = createCtx();+ const spreadsheetSkeleton = createSpreadsheetSkeleton();+ const fontMatrix = new ObjectMatrix<any>();+ fontMatrix.setValue(0, 0, createFontCache());+ spreadsheetSkeleton.stylesCache = { fontMatrix };+ spreadsheetSkeleton.columnTotalWidth = 120;+ spreadsheetSkeleton.rowTotalHeight = 60;+ const getSpanModelSpy = vi.spyOn(spreadsheetSkeleton.worksheet, 'getSpanModel');+ const getMergedCellRangeSpy = vi.spyOn(spreadsheetSkeleton.worksheet, 'getMergedCellRange');+ const renderCellSpy = vi.spyOn(font, '_renderFontEachCell').mockReturnValue(true);++ font.draw(ctx, { scaleX: 1, scaleY: 1 } as any, spreadsheetSkeleton, [], {+ viewRanges: [{ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 }],+ checkOutOfViewBound: true,+ viewportKey: 'viewMain',+ } as any);++ expect(getSpanModelSpy).not.toHaveBeenCalled();+ expect(getMergedCellRangeSpy).not.toHaveBeenCalled();+ expect(renderCellSpy).toHaveBeenCalledOnce();+ });+it('does not mutate shared view ranges when expanding text overflow bounds', () => {const font = new Font() as any;const ctx = createCtx();diff --git a/packages/engine-render/src/components/sheets/extensions/__tests__/marker.spec.ts b/packages/engine-render/src/components/sheets/extensions/__tests__/marker.spec.tsindex 0d508d4bcb..da3fc9da76 100644--- a/packages/engine-render/src/components/sheets/extensions/__tests__/marker.spec.ts+++ b/packages/engine-render/src/components/sheets/extensions/__tests__/marker.spec.ts@@ -72,6 +72,7 @@ describe('marker extension', () => {const ctx = createCtx();const worksheet = {+ getMergeData: vi.fn(() => []),getRowVisible: vi.fn(() => true),getColVisible: vi.fn(() => true),getCell: vi.fn(() => ({@@ -91,6 +92,13 @@ describe('marker extension', () => {marker.draw(ctx, { scaleX: 1, scaleY: 1 } as any, skeleton, [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }]);expect(ctx.fill).toHaveBeenCalledTimes(4);+ expect(ctx.save).not.toHaveBeenCalled();+ expect(ctx.restore).not.toHaveBeenCalled();+ expect(ctx.beginPath).toHaveBeenCalledTimes(4);+ expect(ctx.moveTo).toHaveBeenCalledWith(10, 0);+ expect(ctx.moveTo).toHaveBeenCalledWith(0, 0);+ expect(ctx.moveTo).toHaveBeenCalledWith(10, 20);+ expect(ctx.moveTo).toHaveBeenCalledWith(0, 20);worksheet.getRowVisible.mockReturnValue(false);marker.draw(ctx, { scaleX: 1, scaleY: 1 } as any, skeleton, [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }]);@@ -113,6 +121,12 @@ describe('marker extension', () => {};const worksheet = {+ getMergeData: vi.fn(() => [{+ startRow: 0,+ endRow: 0,+ startColumn: 0,+ endColumn: 1,+ }]),getRowVisible: vi.fn(() => true),getColVisible: vi.fn(() => true),getCell: vi.fn(() => ({@@ -144,6 +158,7 @@ describe('marker extension', () => {const ctx = createCtx();const worksheet = {+ getMergeData: vi.fn(() => []),getRowVisible: vi.fn(() => true),getColVisible: vi.fn(() => true),getCell: vi.fn((row: number) => row === 5@@ -177,4 +192,25 @@ describe('marker extension', () => {expect(worksheet.getCell).toHaveBeenCalledWith(5, 0);expect(ctx.fill).toHaveBeenCalledTimes(1);});++ it('skips coordinate calculation for no-merge cells without markers', () => {+ const marker = new Marker();+ const ctx = createCtx();+ const worksheet = {+ getMergeData: vi.fn(() => []),+ getRowVisible: vi.fn(() => true),+ getColVisible: vi.fn(() => true),+ getCell: vi.fn(() => ({ v: 'plain' })),+ };+ const skeleton = {+ worksheet,+ rowColumnSegment: { startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 },+ getCellWithCoordByIndex: vi.fn(() => createCellInfo()),+ } as any;++ marker.draw(ctx, { scaleX: 1, scaleY: 1 } as any, skeleton, [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }]);++ expect(skeleton.getCellWithCoordByIndex).not.toHaveBeenCalled();+ expect(ctx.fill).not.toHaveBeenCalled();+ });});diff --git a/packages/engine-render/src/components/sheets/extensions/background.ts b/packages/engine-render/src/components/sheets/extensions/background.tsindex 773cf8fdfe..086156b34a 100644--- a/packages/engine-render/src/components/sheets/extensions/background.ts+++ b/packages/engine-render/src/components/sheets/extensions/background.ts@@ -33,6 +33,12 @@ const UNIQUE_KEY = 'DefaultBackgroundExtension';const DOC_EXTENSION_Z_INDEX = 21;const PRINTING_Z_INDEX = 21;+function getRangeCellCount(ranges: IRange[]) {+ return ranges.reduce((sum, range) => {+ return sum + Math.max(range.endRow - range.startRow + 1, 0) * Math.max(range.endColumn - range.startColumn + 1, 0);+ }, 0);+}+interface IRenderBGContext {ctx: UniverRenderingContext;spreadsheetSkeleton: SpreadsheetSkeleton;@@ -44,6 +50,7 @@ interface IRenderBGContext {viewRanges: IRange[];diffRanges: IRange[];cellInfo: ICellWithCoord;+ skipRenderRangeCheck?: boolean;}export class Background extends SheetExtension {@@ -63,7 +70,7 @@ export class Background extends SheetExtension {_parentScale: IScale,spreadsheetSkeleton: SpreadsheetSkeleton,diffRanges: IRange[],- { viewRanges, checkOutOfViewBound }: IDrawInfo+ { viewRanges, checkOutOfViewBound, hasMergeData = true }: IDrawInfo) {const { stylesCache, worksheet, rowHeightAccumulation, columnTotalWidth, columnWidthAccumulation, rowTotalHeight } = spreadsheetSkeleton;const { background: bgMatrixCacheByColor, backgroundPositions } = stylesCache;@@ -90,22 +97,27 @@ export class Background extends SheetExtension {} as IRenderBGContext;const mergeRanges: IRange[] = [];- // Currently, viewRanges has only one range.- viewRanges.forEach((range) => {- // For merge cell.- // The background extension is not as strict as the font extension; the font extension must never be redrawn. Therefore, it is not necessary to be that complex.- const intersectMergeRangesInViewRanges = spreadsheetSkeleton.worksheet.getMergedCellRange(range.startRow, range.startColumn, range.endRow, range.endColumn);- mergeRanges.push(...intersectMergeRangesInViewRanges);- });+ if (hasMergeData) {+ // Currently, viewRanges has only one range.+ viewRanges.forEach((range) => {+ // For merge cell.+ // The background extension is not as strict as the font extension; the font extension must never be redrawn. Therefore, it is not necessary to be that complex.+ const intersectMergeRangesInViewRanges = spreadsheetSkeleton.worksheet.getMergedCellRange(range.startRow, range.startColumn, range.endRow, range.endColumn);+ mergeRanges.push(...intersectMergeRangesInViewRanges);+ });+ }const renderBGCore = (rgb: string) => {const bgColorMatrix = bgMatrixCacheByColor[rgb];+ const renderRanges = diffRanges && diffRanges.length > 0 ? diffRanges : viewRanges;const rangeForEachFn = (row: number, col: number, bgConfigParam?: string) => {- const index = spreadsheetSkeleton.worksheet.getSpanModel().getMergeDataIndex(row, col);- if (index !== -1) {- return;+ if (hasMergeData) {+ const index = spreadsheetSkeleton.worksheet.getSpanModel().getMergeDataIndex(row, col);+ if (index !== -1) {+ return;+ }}- const cellInfo = spreadsheetSkeleton.getCellByIndexWithNoHeader(row, col);+ const cellInfo = backgroundPositions?.getValue(row, col) ?? spreadsheetSkeleton.getCellByIndexWithNoHeader(row, col);if (!cellInfo) return;const bgConfig = bgConfigParam || bgColorMatrix.getValue(row, col);if (bgConfig) {@@ -120,17 +132,18 @@ export class Background extends SheetExtension {ctx.beginPath();const matrixSize = bgColorMatrix.getSizeOf();- const cellCountInRanges = viewRanges.reduce((sum, range) => {- return sum + (range.endRow - range.startRow) * (range.endColumn - range.startColumn);- }, 0);+ const cellCountInRanges = getRangeCellCount(renderRanges);// if number of cells in range is over than bg config in matrix, renderBackground by matrix.- // otherwise, renderBackground by cells in viewRange.+ // otherwise, renderBackground by cells in render range.if (cellCountInRanges < matrixSize) {- // Currently, viewRanges has only one range.- viewRanges.forEach((range) => {+ // Currently, renderRanges has only one range in normal scrolling.+ renderBGContext.skipRenderRangeCheck = true;+ renderRanges.forEach((range) => {Range.foreach(range, rangeForEachFn);});+ renderBGContext.skipRenderRangeCheck = false;} else {+ renderBGContext.skipRenderRangeCheck = false;bgColorMatrix.forValue(rangeForEachFn);}ctx.fill(backgroundPaths);@@ -162,13 +175,15 @@ export class Background extends SheetExtension {for (let index = 0; index < rgbList.length; index++) {const rgb = rgbList[index];renderBGCore(rgb);- renderBGForMergedCells(rgb);+ if (hasMergeData) {+ renderBGForMergedCells(rgb);+ }}ctx.restore();}renderBGByCell(bgContext: IRenderBGContext, row: number, col: number) {- const { spreadsheetSkeleton, backgroundPaths, scaleX, scaleY, viewRanges, diffRanges, cellInfo } = bgContext;+ const { spreadsheetSkeleton, backgroundPaths, scaleX, scaleY, viewRanges, diffRanges, cellInfo, skipRenderRangeCheck } = bgContext;let { startY, endY, startX, endX } = cellInfo;const { isMerged, isMergedMainCell, mergeInfo } = cellInfo;@@ -183,7 +198,7 @@ export class Background extends SheetExtension {endX = mergeInfo.endX;// If curr cell is not in the viewrange (viewport + merged cells), exit early.- if ((!isMerged && !isMergedMainCell) && !inViewRanges(renderRange!, row, col)) {+ if (!skipRenderRangeCheck && (!isMerged && !isMergedMainCell) && !inViewRanges(renderRange!, row, col)) {return true;}diff --git a/packages/engine-render/src/components/sheets/extensions/font.ts b/packages/engine-render/src/components/sheets/extensions/font.tsindex 206537bbb6..b0f999f3d0 100644--- a/packages/engine-render/src/components/sheets/extensions/font.ts+++ b/packages/engine-render/src/components/sheets/extensions/font.ts@@ -38,7 +38,6 @@ import {CellValueType,getDisplayValueFromCell,HorizontalAlign,- Range,Tools,VerticalAlign,WrapStrategy,@@ -63,6 +62,32 @@ function rotatedBoundingBox(width: number, height: number, angleDegrees: number)return { rotatedWidth, rotatedHeight };}+function getResolvedRenderHorizontalAlign(fontCache: IFontCacheItem, cellData: ICellDataForSheetInterceptor): HorizontalAlign {+ if (fontCache.resolvedHorizontalAlign !== undefined) {+ return fontCache.resolvedHorizontalAlign;+ }++ const { horizontalAlign } = fontCache;+ if (horizontalAlign !== HorizontalAlign.UNSPECIFIED) {+ return horizontalAlign;+ }++ if (cellData.t === CellValueType.NUMBER || (!Tools.isDefine(cellData.t) && typeof cellData.v === 'number')) {+ return HorizontalAlign.RIGHT;+ }++ if (cellData.t === CellValueType.BOOLEAN) {+ return HorizontalAlign.CENTER;+ }++ return horizontalAlign;+}++function needsFontRenderExtensionBounds(fontCache: IFontCacheItem) {+ const extension = fontCache.cellData?.fontRenderExtension;+ return Boolean(extension?.isSkip || extension?.leftOffset || extension?.rightOffset);+}+interface IRenderFontContext {ctx: UniverRenderingContext;scale: number;@@ -153,7 +178,7 @@ export class Font extends SheetExtension {}const scale = this._getScale(parentScale);- const { viewRanges = [], checkOutOfViewBound } = moreBoundsInfo;+ const { fontRenderRanges, viewRanges = [], checkOutOfViewBound } = moreBoundsInfo;const lastRowIndex = spreadsheetSkeleton.getRowCount() - 1;const lastColIndex = spreadsheetSkeleton.getColumnCount() - 1;const expandedViewRanges = viewRanges.map((range) => clampRange({@@ -161,6 +186,7 @@ export class Font extends SheetExtension {startColumn: range.startColumn - EXPAND_SIZE_FOR_RENDER_OVERFLOW,endColumn: range.endColumn + EXPAND_SIZE_FOR_RENDER_OVERFLOW,}, lastRowIndex, lastColIndex));+ const rangesToScan = fontRenderRanges?.length ? fontRenderRanges : expandedViewRanges;const renderFontContext = {ctx,scale,@@ -168,59 +194,76 @@ export class Font extends SheetExtension {columnTotalWidth,// columnWidthAccumulation,rowTotalHeight,- viewRanges: expandedViewRanges,+ viewRanges: fontRenderRanges?.length ? viewRanges : expandedViewRanges,checkOutOfViewBound: checkOutOfViewBound || true,diffRanges,spreadsheetSkeleton,} as IRenderFontContext;ctx.save();+ const mergeData = spreadsheetSkeleton.worksheet.getMergeData();+ const hasMerge = mergeData.length > 0;const uniqueMergeRanges: IRange[] = [];- const mergeRangeIDSet = new Set();+ const mergeRangeIDSet = hasMerge ? new Set() : null;+ const spanModel = hasMerge ? spreadsheetSkeleton.worksheet.getSpanModel() : null;// Currently, viewRanges has only one range.- expandedViewRanges.forEach((range) => {- // collect unique merge ranges intersect with view range.- // The ranges in mergeRanges must be unique. Otherwise, the font will render, text redrawing causes jagged edges or artifacts.- const intersectMergeRangesWithViewRanges = spreadsheetSkeleton.worksheet.getMergedCellRange(- range.startRow,- range.startColumn,- range.endRow,- range.endColumn- );- intersectMergeRangesWithViewRanges.forEach((mergeRange) => {- const mergeRangeIndex = spreadsheetSkeleton.worksheet.getSpanModel().getMergeDataIndex(mergeRange.startRow, mergeRange.startColumn);- if (!mergeRangeIDSet.has(mergeRangeIndex)) {- mergeRangeIDSet.add(mergeRangeIndex);- uniqueMergeRanges.push(mergeRange);- }- });+ rangesToScan.forEach((range) => {+ if (hasMerge && spanModel && mergeRangeIDSet) {+ // collect unique merge ranges intersect with view range.+ // The ranges in mergeRanges must be unique. Otherwise, the font will render, text redrawing causes jagged edges or artifacts.+ const intersectMergeRangesWithViewRanges = spreadsheetSkeleton.worksheet.getMergedCellRange(+ range.startRow,+ range.startColumn,+ range.endRow,+ range.endColumn+ );+ intersectMergeRangesWithViewRanges.forEach((mergeRange) => {+ const mergeRangeIndex = spanModel.getMergeDataIndex(mergeRange.startRow, mergeRange.startColumn);+ if (!mergeRangeIDSet.has(mergeRangeIndex)) {+ mergeRangeIDSet.add(mergeRangeIndex);+ uniqueMergeRanges.push(mergeRange);+ }+ });+ }- Range.foreach(range, (row, col) => {- const index = spreadsheetSkeleton.worksheet.getSpanModel().getMergeDataIndex(row, col);- if (index !== -1) {- return;- }- const cellInfo = spreadsheetSkeleton.getCellWithCoordByIndex(row, col, false);- if (!cellInfo) {- return;- }+ const { startRow, endRow, startColumn, endColumn } = range;+ for (let row = startRow; row <= endRow; row++) {+ for (let col = startColumn; col <= endColumn; col++) {+ const fontCache = fontMatrix.getValue(row, col);+ if (!fontCache) {+ continue;+ }- renderFontContext.cellInfo = cellInfo;- this._renderFontEachCell(renderFontContext, row, col, fontMatrix);- });+ if (spanModel && spanModel.getMergeDataIndex(row, col) !== -1) {+ continue;+ }+ const cellInfo = spreadsheetSkeleton.getCellWithCoordByIndex(row, col, false);+ if (!cellInfo) {+ continue;+ }++ renderFontContext.cellInfo = cellInfo;+ this._renderFontEachCell(renderFontContext, row, col, fontMatrix, fontCache);+ }+ }});uniqueMergeRanges.forEach((range) => {+ const fontCache = fontMatrix.getValue(range.startRow, range.startColumn);+ if (!fontCache) {+ return;+ }+const cellInfo = spreadsheetSkeleton.getCellWithCoordByIndex(range.startRow, range.startColumn, false);renderFontContext.cellInfo = cellInfo;- this._renderFontEachCell(renderFontContext, range.startRow, range.startColumn, fontMatrix);+ this._renderFontEachCell(renderFontContext, range.startRow, range.startColumn, fontMatrix, fontCache);});ctx.restore();}- _renderFontEachCell(renderFontCtx: IRenderFontContext, row: number, col: number, fontMatrix: ObjectMatrix<IFontCacheItem>) {+ _renderFontEachCell(renderFontCtx: IRenderFontContext, row: number, col: number, fontMatrix: ObjectMatrix<IFontCacheItem>, cacheValue?: IFontCacheItem) {const { ctx, viewRanges, diffRanges, spreadsheetSkeleton, cellInfo } = renderFontCtx;//#region merged cell@@ -246,7 +289,7 @@ export class Font extends SheetExtension {//#endregion- const fontCache = fontMatrix.getValue(row, col);+ const fontCache = cacheValue ?? fontMatrix.getValue(row, col);if (!fontCache) return true;renderFontCtx.fontCache = fontCache;@@ -270,10 +313,14 @@ export class Font extends SheetExtension {if (notInMergeRange) {const visibleRow = spreadsheetSkeleton.worksheet.getRowVisible(row);- if (!visibleRow) return true;+ if (!visibleRow) {+ return true;+ }const visibleCol = spreadsheetSkeleton.worksheet.getColVisible(col);- if (!visibleCol) return true;+ if (!visibleCol) {+ return true;+ }} else {let isAllRowHidden = true;@@ -285,7 +332,9 @@ export class Font extends SheetExtension {}}- if (isAllRowHidden) return true;+ if (isAllRowHidden) {+ return true;+ }let isAllColHidden = true;@@ -297,15 +346,27 @@ export class Font extends SheetExtension {}}- if (isAllColHidden) return true;+ if (isAllColHidden) {+ return true;+ }}- // Since we cannot predict when fontRenderExtension?.isSkip might change,- // we must check it every time and retrieve cell data directly from the worksheet,- // not from the cache to ensure accuracy.- const cellData = spreadsheetSkeleton.worksheet.getCell(row, col) as ICellDataForSheetInterceptor || {};- if (cellData?.fontRenderExtension?.isSkip) {- return true;+ // For cells with render extensions, isSkip may be updated by render interceptors.+ // Plain cells avoid the extra worksheet lookup on every scroll repaint.+ if (fontCache.cellData?.fontRenderExtension) {+ const cellData = spreadsheetSkeleton.worksheet.getCell(row, col) as ICellDataForSheetInterceptor || {};+ if (cellData?.fontRenderExtension?.isSkip) {+ return true;+ }+ }++ if (this._renderPlainTextWithoutClip(ctx, renderFontCtx, fontCache)) {+ renderFontCtx.startX = 0;+ renderFontCtx.startY = 0;+ renderFontCtx.endX = 0;+ renderFontCtx.endY = 0;+ renderFontCtx.overflowRectangle = null;+ return false;}ctx.save();@@ -322,7 +383,6 @@ export class Font extends SheetExtension {} else {this._renderText(ctx, row, col, renderFontCtx, spreadsheetSkeleton.overflowCache);}- ctx.closePath();ctx.restore();if (fontCache.documentSkeleton) {@@ -345,6 +405,57 @@ export class Font extends SheetExtension {return false;};+ private _renderPlainTextWithoutClip(ctx: UniverRenderingContext, renderFontCtx: IRenderFontContext, fontCache: IFontCacheItem) {+ const { cellData, documentSkeleton, textFitsCurrentCell, vertexAngle = 0, centerAngle = 0, wrapStrategy } = fontCache;+ if (!textFitsCurrentCell) {+ return false;+ }+ if (documentSkeleton) {+ return false;+ }+ if (vertexAngle !== 0 || centerAngle !== 0) {+ return false;+ }+ if (wrapStrategy === WrapStrategy.WRAP) {+ return false;+ }+ if (needsFontRenderExtensionBounds(fontCache)) {+ return false;+ }+ if (fontCache.style?.st?.s || fontCache.style?.ul?.s) {+ return false;+ }+ if (cellData?.v === undefined || cellData?.v === null) {+ return false;+ }++ const padding = fontCache.style?.pd ?? DEFAULT_PADDING_DATA;+ const paddingLeft = padding.l ?? DEFAULT_PADDING_DATA.l;+ const paddingRight = padding.r ?? DEFAULT_PADDING_DATA.r;+ const paddingTop = padding.t ?? DEFAULT_PADDING_DATA.t;+ const paddingBottom = padding.b ?? DEFAULT_PADDING_DATA.b;+ const text = fontCache.displayText ?? getDisplayValueFromCell(cellData);+ const { startX, startY, endX, endY } = renderFontCtx;+ const cellWidth = endX - startX - paddingLeft - paddingRight;+ const cellHeight = endY - startY - paddingTop - paddingBottom;+ const hAlign = getResolvedRenderHorizontalAlign(fontCache, cellData);++ Text.drawPlainWith(ctx, {+ text,+ fontStyle: fontCache.fontString,+ hAlign,+ vAlign: fontCache.verticalAlign,+ width: cellWidth,+ height: cellHeight,+ left: startX + FIX_ONE_PIXEL_BLUR_OFFSET + paddingLeft,+ top: startY + FIX_ONE_PIXEL_BLUR_OFFSET + paddingTop,+ color: fontCache.style?.cl?.rgb,+ cellValueType: cellData.t,+ });++ return true;+ }+private _renderImages(ctx: UniverRenderingContext, fontsConfig: IFontCacheItem, startX: number, startY: number, endX: number, endY: number) {const { documentSkeleton, verticalAlign, horizontalAlign } = fontsConfig;const PADDING = 2;@@ -547,24 +658,13 @@ export class Font extends SheetExtension {const paddingBottom = padding.b ?? DEFAULT_PADDING_DATA.b;const { vertexAngle = 0, wrapStrategy, cellData } = fontCache;if (cellData?.v === undefined || cellData?.v === null) return;- const text = getDisplayValueFromCell(cellData);+ const text = fontCache.displayText ?? getDisplayValueFromCell(cellData);const { startX, startY, endX, endY } = renderFontCtx;const cellWidth = endX - startX - paddingLeft - paddingRight;const cellHeight = endY - startY - paddingTop - paddingBottom;+ const hAlign = getResolvedRenderHorizontalAlign(fontCache, cellData);- // If the horizontal alignment is not specified, we need to determine it based on the cell value type.- let hAlign = fontCache.horizontalAlign;- if (fontCache.horizontalAlign === HorizontalAlign.UNSPECIFIED) {- if (cellData.t === CellValueType.NUMBER || (!Tools.isDefine(cellData.t) && typeof cellData.v === 'number')) {- // If the cell value is a number, default to right alignment.- hAlign = HorizontalAlign.RIGHT;- } else if (cellData.t === CellValueType.BOOLEAN) {- // If the cell value is a boolean, default to center alignment.- hAlign = HorizontalAlign.CENTER;- }- }-- Text.drawWith(ctx, {+ const textProps = {text,fontStyle: fontCache.fontString,warp: wrapStrategy === WrapStrategy.WRAP && vertexAngle === 0,@@ -579,7 +679,14 @@ export class Font extends SheetExtension {underline: Boolean(fontCache.style?.ul?.s),underlineType: fontCache.style?.ul?.t,cellValueType: cellData.t,- });+ };++ if (!textProps.warp && !textProps.strokeLine && !textProps.underline) {+ Text.drawPlainWith(ctx, textProps);+ return;+ }++ Text.drawWith(ctx, textProps);}private _renderDocuments(diff --git a/packages/engine-render/src/components/sheets/extensions/marker.ts b/packages/engine-render/src/components/sheets/extensions/marker.tsindex c7bd086bfd..fdd58609cb 100644--- a/packages/engine-render/src/components/sheets/extensions/marker.ts+++ b/packages/engine-render/src/components/sheets/extensions/marker.ts@@ -17,7 +17,6 @@import type { IRange, IScale } from '@univerjs/core';import type { UniverRenderingContext } from '../../../context';import type { SpreadsheetSkeleton } from '../sheet.render-skeleton';-import { Range } from '@univerjs/core';import { SpreadsheetExtensionRegistry } from '../../extension';import { SheetExtension } from './sheet-extension';@@ -30,6 +29,16 @@ const stringifyRange = (range: IRange) => {return `${startRow}-${endRow}-${startColumn}-${endColumn}`;};+function drawTriangleMarker(ctx: UniverRenderingContext, color: string, x: number, y: number, x2: number, y2: number, x3: number, y3: number) {+ ctx.fillStyle = color;+ ctx.beginPath();+ ctx.moveTo(x, y);+ ctx.lineTo(x2, y2);+ ctx.lineTo(x3, y3);+ ctx.closePath();+ ctx.fill();+}+export class Marker extends SheetExtension {protected override Z_INDEX: number = Z_INDEX;@@ -53,117 +62,87 @@ export class Marker extends SheetExtension {const mergeCellRendered = new Set<string>();const renderRanges = diffRanges?.length ? diffRanges : [rowColumnSegment];+ const hasMerge = worksheet.getMergeData().length > 0;- // eslint-disable-next-line max-lines-per-functionrenderRanges.forEach((range) => {- // eslint-disable-next-line max-lines-per-function- Range.foreach(range, (row, col) => {- if (!worksheet.getRowVisible(row) || !worksheet.getColVisible(col)) {- return;- }+ const { startRow, endRow, startColumn, endColumn } = range;+ for (let row = startRow; row <= endRow; row++) {+ for (let col = startColumn; col <= endColumn; col++) {+ if (!worksheet.getRowVisible(row) || !worksheet.getColVisible(col)) {+ continue;+ }- let cellData = worksheet.getCell(row, col);- const cellInfo = skeleton.getCellWithCoordByIndex(row, col, false);- const { isMerged, isMergedMainCell, mergeInfo } = cellInfo;- let { startY, endY, startX, endX } = cellInfo;+ let cellData = worksheet.getCell(row, col);+ if (!hasMerge && !cellData?.markers) {+ continue;+ }- if (isMergedMainCell || isMerged) {- startY = mergeInfo.startY;- endY = mergeInfo.endY;- startX = mergeInfo.startX;- endX = mergeInfo.endX;- }+ const cellInfo = skeleton.getCellWithCoordByIndex(row, col, false);+ const { isMerged, isMergedMainCell, mergeInfo } = cellInfo;+ let { startY, endY, startX, endX } = cellInfo;- if (isMerged) {- const mainCell = {- row: mergeInfo.startRow,- col: mergeInfo.startColumn,- };+ if (isMergedMainCell || isMerged) {+ startY = mergeInfo.startY;+ endY = mergeInfo.endY;+ startX = mergeInfo.startX;+ endX = mergeInfo.endX;+ }- cellData = worksheet.getCell(mainCell.row, mainCell.col);- }+ if (isMerged) {+ const mainCell = {+ row: mergeInfo.startRow,+ col: mergeInfo.startColumn,+ };- if (!this.isRenderDiffRangesByRow(mergeInfo.startRow, mergeInfo.endRow, diffRanges)) {- return true;- }+ cellData = worksheet.getCell(mainCell.row, mainCell.col);+ }- if (cellInfo.isMerged || cellInfo.isMergedMainCell) {- const rangeStr = stringifyRange(mergeInfo);- if (mergeCellRendered.has(rangeStr)) {- return;+ if (!this.isRenderDiffRangesByRow(mergeInfo.startRow, mergeInfo.endRow, diffRanges)) {+ continue;}- mergeCellRendered.add(rangeStr);- }+ if (cellInfo.isMerged || cellInfo.isMergedMainCell) {+ const rangeStr = stringifyRange(mergeInfo);+ if (mergeCellRendered.has(rangeStr)) {+ continue;+ }- if (!cellData) {- return;- }+ mergeCellRendered.add(rangeStr);+ }- if (cellData.markers?.tr) {- ctx.save();- const marker = cellData.markers.tr;- const x = endX;- const y = startY;- ctx.fillStyle = marker.color;- ctx.moveTo(x, y);- ctx.beginPath();- ctx.lineTo(x - marker.size, y);- ctx.lineTo(x, y + marker.size);- ctx.lineTo(x, y);- ctx.closePath();- ctx.fill();- ctx.restore();- }+ if (!cellData) {+ continue;+ }- if (cellData.markers?.tl) {- ctx.save();- const marker = cellData.markers.tl;- const x = startX;- const y = startY;- ctx.fillStyle = marker.color;- ctx.moveTo(x, y);- ctx.beginPath();- ctx.lineTo(x + marker.size, y);- ctx.lineTo(x, y + marker.size);- ctx.lineTo(x, y);- ctx.closePath();- ctx.fill();- ctx.restore();- }+ if (cellData.markers?.tr) {+ const marker = cellData.markers.tr;+ const x = endX;+ const y = startY;+ drawTriangleMarker(ctx, marker.color, x, y, x - marker.size, y, x, y + marker.size);+ }- if (cellData.markers?.br) {- ctx.save();- const marker = cellData.markers.br;- const x = endX;- const y = endY;- ctx.fillStyle = marker.color;- ctx.moveTo(x, y);- ctx.beginPath();- ctx.lineTo(x - marker.size, y);- ctx.lineTo(x, y - marker.size);- ctx.lineTo(x, y);- ctx.closePath();- ctx.fill();- ctx.restore();- }+ if (cellData.markers?.tl) {+ const marker = cellData.markers.tl;+ const x = startX;+ const y = startY;+ drawTriangleMarker(ctx, marker.color, x, y, x + marker.size, y, x, y + marker.size);+ }- if (cellData.markers?.bl) {- ctx.save();- const marker = cellData.markers.bl;- const x = startX;- const y = endY;- ctx.fillStyle = marker.color;- ctx.moveTo(x, y);- ctx.beginPath();- ctx.lineTo(x + marker.size, y);- ctx.lineTo(x, y - marker.size);- ctx.lineTo(x, y);- ctx.closePath();- ctx.fill();- ctx.restore();+ if (cellData.markers?.br) {+ const marker = cellData.markers.br;+ const x = endX;+ const y = endY;+ drawTriangleMarker(ctx, marker.color, x, y, x - marker.size, y, x, y - marker.size);+ }++ if (cellData.markers?.bl) {+ const marker = cellData.markers.bl;+ const x = startX;+ const y = endY;+ drawTriangleMarker(ctx, marker.color, x, y, x + marker.size, y, x, y - marker.size);+ }}- });+ }});}}diff --git a/packages/engine-render/src/components/sheets/interfaces.ts b/packages/engine-render/src/components/sheets/interfaces.tsindex a36455a47d..d9a94710fa 100644--- a/packages/engine-render/src/components/sheets/interfaces.ts+++ b/packages/engine-render/src/components/sheets/interfaces.ts@@ -52,6 +52,9 @@ export interface IFontCacheItem {cellData: Nullable<ICellDataForSheetInterceptor>;fontString: string;style?: Nullable<IStyleData>;+ displayText?: string;+ resolvedHorizontalAlign?: HorizontalAlign;+ textFitsCurrentCell?: boolean;}type colorString = string;diff --git a/packages/engine-render/src/components/sheets/sheet.render-skeleton.ts b/packages/engine-render/src/components/sheets/sheet.render-skeleton.tsindex 1593395cbe..5e8d80a867 100644--- a/packages/engine-render/src/components/sheets/sheet.render-skeleton.ts+++ b/packages/engine-render/src/components/sheets/sheet.render-skeleton.ts@@ -54,6 +54,7 @@ import {IContextService,Inject,Injector,+ isCellCoverable,isNullCell,isWhiteColor,LocaleService,@@ -92,6 +93,7 @@ const DEFAULT_CELL_DOCUMENT_MODEL_OPTION: ICellDocumentModelOption = {};interface IRowColumnRange extends IRowRange, IColumnRange { }+export interface IDocumentLayoutObject {documentModel: Nullable<DocumentDataModel>;fontString: string;@@ -112,11 +114,71 @@ export const DEFAULT_PADDING_DATA = {export const RENDER_RAW_FORMULA_KEY = 'RENDER_RAW_FORMULA';+function getResolvedRenderHorizontalAlign(+ horizontalAlign: HorizontalAlign,+ cellData: Nullable<ICellDataForSheetInterceptor>+): HorizontalAlign {+ if (horizontalAlign !== HorizontalAlign.UNSPECIFIED) {+ return horizontalAlign;+ }++ if (cellData?.t === CellValueType.NUMBER || (!Tools.isDefine(cellData?.t) && typeof cellData?.v === 'number')) {+ return HorizontalAlign.RIGHT;+ }++ if (cellData?.t === CellValueType.BOOLEAN) {+ return HorizontalAlign.CENTER;+ }++ return horizontalAlign;+}++function setRenderTextCache(cacheItem: IFontCacheItem, cellData: Nullable<ICellDataForSheetInterceptor>): void {+ if (cacheItem.documentSkeleton) {+ cacheItem.displayText = undefined;+ cacheItem.resolvedHorizontalAlign = undefined;+ return;+ }++ cacheItem.displayText = getDisplayValueFromCell(cellData);+ cacheItem.resolvedHorizontalAlign = getResolvedRenderHorizontalAlign(+ cacheItem.horizontalAlign ?? HorizontalAlign.UNSPECIFIED,+ cellData+ );+}++function pushRowRange(ranges: IRange[], row: number, startColumn: number, endColumn: number): void {+ if (endColumn < startColumn) {+ return;+ }++ const last = ranges[ranges.length - 1];+ if (last && last.startRow === row && last.endRow === row && last.endColumn + 1 === startColumn) {+ last.endColumn = endColumn;+ return;+ }++ ranges.push({+ startRow: row,+ endRow: row,+ startColumn,+ endColumn,+ });+}+export interface ICacheItem {bg: boolean;border: boolean;}+interface ISetStylesCacheForOneCellOptions {+ mergeRange?: IRange;+ cacheItem?: ICacheItem;+ reuseExisting?: boolean;+ hasMergeData?: boolean;+ rowVisible?: boolean;+}+export interface IGetPosByRowColOptions {closeFirst?: boolean;@@ -146,6 +208,8 @@ export class SpreadsheetSkeleton extends SheetSkeleton {// private _dataMergeCache: IRange[] = [];private _overflowCache: ObjectMatrix<IRange> = new ObjectMatrix();++ private _incrementalFontRenderRanges: IRange[] = [];private _stylesCache: IStylesCache = {background: {},backgroundPositions: new ObjectMatrix<ICellWithCoord>(),@@ -235,6 +299,10 @@ export class SpreadsheetSkeleton extends SheetSkeleton {return this._overflowCache;}+ get incrementalFontRenderRanges(): IRange[] {+ return this._incrementalFontRenderRanges;+ }+get showGridlines(): BooleanNumber {return this._showGridlines;}@@ -359,9 +427,23 @@ export class SpreadsheetSkeleton extends SheetSkeleton {!!vpInfo.diffX ||!!vpInfo.diffY);- const styleRanges = isIncrementalScroll+ const hasMergeData = this.worksheet.getMergeData().length > 0;+ const isScrolling = !!vpInfo && (!!vpInfo.diffX || !!vpInfo.diffY);+ const shouldRefreshCacheForScroll = isIncrementalScroll && (+ (hasMergeData && isScrolling) ||+ (!!vpInfo.shouldCacheUpdate && !!vpInfo.diffX)+ );+ const shouldUseIncrementalStyleRange = isIncrementalScroll && !shouldRefreshCacheForScroll;+ const styleRanges = shouldUseIncrementalStyleRange? (vpInfo.shouldCacheUpdate ? (vpInfo.diffCacheBounds?.map((bound) => this.getRangeByViewBound(bound)) ?? []) : []): [rowColumnSegment];+ const visibleCellOptions: ISetStylesCacheForOneCellOptions | null = hasMergeData+ ? null+ : { cacheItem: { bg: true, border: true }, reuseExisting: shouldUseIncrementalStyleRange, hasMergeData, rowVisible: true };+ const overflowCellOptions: ISetStylesCacheForOneCellOptions | null = hasMergeData+ ? null+ : { cacheItem: { bg: false, border: false }, reuseExisting: shouldUseIncrementalStyleRange, hasMergeData, rowVisible: true };+ this._incrementalFontRenderRanges = [];// clear cache out of visible range// this._clearCacheOutOfVisibleRange(visibleStartRow, visibleEndRow, visibleStartColumn, visibleEndColumn);@@ -401,18 +483,35 @@ export class SpreadsheetSkeleton extends SheetSkeleton {}for (let c = visibleStartColumn; c <= visibleEndColumn; c++) {- this._setStylesCacheForOneCell(r, c, { cacheItem: { bg: true, border: true } });+ this._setStylesCacheForOneCell(r, c, visibleCellOptions ?? { cacheItem: { bg: true, border: true }, reuseExisting: shouldUseIncrementalStyleRange, hasMergeData, rowVisible: true });+ }+ if (shouldUseIncrementalStyleRange) {+ pushRowRange(this._incrementalFontRenderRanges, r, visibleStartColumn, visibleEndColumn);}- // Calculate the text length for overflow situations, focusing on the leftmost column within the visible range.- for (let c = expandStartCol; c < visibleEndColumn; c++) {- this._setStylesCacheForOneCell(r, c, { cacheItem: { bg: false, border: false } });+ // Calculate text length for overflow cells just outside the visible range.+ for (let c = visibleStartColumn - 1; c >= expandStartCol; c--) {+ this._setStylesCacheForOneCell(r, c, overflowCellOptions ?? { cacheItem: { bg: false, border: false }, reuseExisting: shouldUseIncrementalStyleRange, hasMergeData, rowVisible: true });+ if (shouldUseIncrementalStyleRange) {+ pushRowRange(this._incrementalFontRenderRanges, r, c, c);+ }+ const cell = this.worksheet.getCell(r, c);+ if (!isCellCoverable(cell) || (hasMergeData && this.intersectMergeRange(r, c))) {+ break;+ }}if (visibleEndColumn === 0) continue;- // Calculate the text length for overflow situations, focusing on the rightmost column within the visible range.- for (let c = visibleEndColumn + 1; c < expandEndCol; c++) {- this._setStylesCacheForOneCell(r, c, { cacheItem: { bg: false, border: false } });+ // Calculate text length for overflow cells just outside the visible range.+ for (let c = visibleEndColumn + 1; c <= expandEndCol; c++) {+ this._setStylesCacheForOneCell(r, c, overflowCellOptions ?? { cacheItem: { bg: false, border: false }, reuseExisting: shouldUseIncrementalStyleRange, hasMergeData, rowVisible: true });+ if (shouldUseIncrementalStyleRange) {+ pushRowRange(this._incrementalFontRenderRanges, r, c, c);+ }+ const cell = this.worksheet.getCell(r, c);+ if (!isCellCoverable(cell) || (hasMergeData && this.intersectMergeRange(r, c))) {+ break;+ }}}@@ -424,7 +523,12 @@ export class SpreadsheetSkeleton extends SheetSkeleton {for (const mergeRange of mergeRanges) {this._setStylesCacheForOneCell(mergeRange.startRow, mergeRange.startColumn, {mergeRange,+ reuseExisting: shouldUseIncrementalStyleRange,+ hasMergeData,});+ if (shouldUseIncrementalStyleRange) {+ pushRowRange(this._incrementalFontRenderRanges, mergeRange.startRow, mergeRange.startColumn, mergeRange.startColumn);+ }}}@@ -887,6 +991,37 @@ export class SpreadsheetSkeleton extends SheetSkeleton {};}+ private _isOverflowBlockedByAdjacentCell(row: number, column: number, horizontalAlign: HorizontalAlign, hasMergeData = true): boolean {+ const leftBlocked = () => this._isOverflowSideBlocked(row, column, -1, hasMergeData);+ const rightBlocked = () => this._isOverflowSideBlocked(row, column, 1, hasMergeData);++ if (horizontalAlign === HorizontalAlign.CENTER) {+ return leftBlocked() && rightBlocked();+ }++ if (horizontalAlign === HorizontalAlign.RIGHT) {+ return leftBlocked();+ }++ return rightBlocked();+ }++ private _isOverflowSideBlocked(row: number, column: number, direction: -1 | 1, hasMergeData = true): boolean {+ const adjacentColumn = column + direction;+ if (adjacentColumn < 0 || adjacentColumn >= this.getColumnCount()) {+ return true;+ }++ const rawAdjacentCell = this._cellData.getValue(row, adjacentColumn);+ if (rawAdjacentCell && !isCellCoverable(rawAdjacentCell)) {+ return true;+ }++ const cachedAdjacentCell = this._stylesCache.fontMatrix.getValue(row, adjacentColumn)?.cellData;+ const adjacentCell = cachedAdjacentCell ?? this.worksheet.getCell(row, adjacentColumn);+ return !isCellCoverable(adjacentCell) || (hasMergeData && this.intersectMergeRange(row, adjacentColumn));+ }+/*** Get cell by pos(offsetX, offsetY).* @deprecated Please use `getCellWithCoordByOffset` instead.@@ -1120,7 +1255,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {* Overflow on the left or right is aligned according to the text's horizontal alignment.*/// eslint-disable-next-line complexity, max-lines-per-function- private _calculateOverflowCell(row: number, column: number, docsConfig: IFontCacheItem): boolean {+ private _calculateOverflowCell(row: number, column: number, docsConfig: IFontCacheItem, hasMergeData = true): boolean {// wrap and angle handlerconst { documentSkeleton, vertexAngle = 0, centerAngle = 0, horizontalAlign, wrapStrategy } = docsConfig;const cell = this._cellData.getValue(row, column);@@ -1137,7 +1272,6 @@ export class SpreadsheetSkeleton extends SheetSkeleton {horizontalAlignPos = HorizontalAlign.RIGHT;}}-/*** Numerical and Boolean values are not displayed with overflow.*/@@ -1147,8 +1281,18 @@ export class SpreadsheetSkeleton extends SheetSkeleton {cellValueType !== CellValueType.BOOLEAN &&horizontalAlign !== HorizontalAlign.JUSTIFIED) {+ docsConfig.textFitsCurrentCell = false;// Merged cells do not support overflow.- if (this.intersectMergeRange(row, column)) {+ if (hasMergeData && this.intersectMergeRange(row, column)) {+ return true;+ }++ const columnStart = this.columnWidthAccumulation[column - 1] || 0;+ const columnEnd = this.columnWidthAccumulation[column] || columnStart;+ const currentColumnWidth = columnEnd - columnStart;+ const rawText = docsConfig.cellData?.p?.body?.dataStream ?? docsConfig.cellData?.v;+ const mayOverflowCurrentColumn = Boolean(documentSkeleton) || `${rawText ?? ''}`.length * 4 > currentColumnWidth;+ if (mayOverflowCurrentColumn && this._isOverflowBlockedByAdjacentCell(row, column, horizontalAlignPos, hasMergeData)) {return true;}@@ -1184,6 +1328,11 @@ export class SpreadsheetSkeleton extends SheetSkeleton {}}+ if (contentSize.width < currentColumnWidth) {+ docsConfig.textFitsCurrentCell = true;+ return true;+ }+const position = this.getOverflowPosition(contentSize, horizontalAlignPos, row, column, this.getColumnCount());const { startColumn, endColumn } = position;@@ -1195,7 +1344,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {this.appendToOverflowCache(row, column, startColumn, endColumn);} else if (wrapStrategy === WrapStrategy.WRAP && vertexAngle !== 0) {// Merged cells do not support overflow.- if (this.intersectMergeRange(row, column)) {+ if (hasMergeData && this.intersectMergeRange(row, column)) {return true;}@@ -1338,15 +1487,19 @@ export class SpreadsheetSkeleton extends SheetSkeleton {const range = ranges[i];Range.foreach(range, (row, col) => {this._stylesCache.fontMatrix.realDeleteValue(row, col);+ this._stylesCache.border?.realDeleteValue(row, col);+ this._stylesCache.backgroundPositions?.realDeleteValue(row, col);+ this._handleBgMatrix.realDeleteValue(row, col);+ this._handleBorderMatrix.realDeleteValue(row, col);+ Object.values(this._stylesCache.background ?? {}).forEach((backgroundMatrix) => {+ backgroundMatrix.realDeleteValue(row, col);+ });});}this.makeDirty(true);}- _setBorderStylesCache(row: number, col: number, style: Nullable<IStyleData>, options: {- mergeRange?: IRange;- cacheItem?: ICacheItem;- } | undefined) {+ _setBorderStylesCache(row: number, col: number, style: Nullable<IStyleData>, options: ISetStylesCacheForOneCellOptions | undefined) {const handledThisCell = Tools.isDefine(this._handleBorderMatrix.getValue(row, col));if (handledThisCell && !options?.mergeRange) return;// by default, style cache should includes border and background info.@@ -1377,10 +1530,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {}}- _setBgStylesCache(row: number, col: number, style: Nullable<IStyleData>, options: {- mergeRange?: IRange;- cacheItem?: ICacheItem;- } | undefined) {+ _setBgStylesCache(row: number, col: number, style: Nullable<IStyleData>, options: ISetStylesCacheForOneCellOptions | undefined) {const handledThisCell = Tools.isDefine(this._handleBgMatrix.getValue(row, col));if (handledThisCell) return;// by default, style cache should includes border and background info.@@ -1401,7 +1551,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {}}- _setFontStylesCache(row: number, col: number, cellData: Nullable<ICellDataForSheetInterceptor>, style: IStyleData) {+ _setFontStylesCache(row: number, col: number, cellData: Nullable<ICellDataForSheetInterceptor>, style: IStyleData, hasMergeData = true) {if (isNullCell(cellData)) return;let config: Partial<IFontCacheItem> = {@@ -1415,6 +1565,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {} else {const cacheItem = cacheValue as IFontCacheItem;cacheItem.cellData = cellData;+ setRenderTextCache(cacheItem, cellData);this._stylesCache.fontMatrix.setValue(row, col, cacheValue as IFontCacheItem);return;}@@ -1464,8 +1615,10 @@ export class SpreadsheetSkeleton extends SheetSkeleton {style,};}- this._calculateOverflowCell(row, col, config as IFontCacheItem);- this._stylesCache.fontMatrix.setValue(row, col, config as IFontCacheItem);+ const fontCacheItem = config as IFontCacheItem;+ setRenderTextCache(fontCacheItem, cellData);+ this._calculateOverflowCell(row, col, fontCacheItem, hasMergeData);+ this._stylesCache.fontMatrix.setValue(row, col, fontCacheItem);}/**@@ -1474,7 +1627,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {* @param col {number}* @param options {{ mergeRange: IRange; cacheItem: ICacheItem } | undefined}*/- private _setStylesCacheForOneCell(row: number, col: number, options: { mergeRange?: IRange; cacheItem?: ICacheItem }): void {+ private _setStylesCacheForOneCell(row: number, col: number, options: ISetStylesCacheForOneCellOptions): void {// when row/col would be negative ?if (row === -1 || col === -1) {return;@@ -1492,13 +1645,30 @@ export class SpreadsheetSkeleton extends SheetSkeleton {options = { cacheItem: { bg: true, border: true } };}- const { isMerged, isMergedMainCell, startRow, startColumn, endRow, endColumn } = this.worksheet.getCellInfoInMergeData(row, col);+ const cacheItem = options.cacheItem;+ if (options.reuseExisting && cacheItem && !options.mergeRange) {+ const bgHandled = !cacheItem.bg || Tools.isDefine(this._handleBgMatrix.getValue(row, col));+ const borderHandled = !cacheItem.border || Tools.isDefine(this._handleBorderMatrix.getValue(row, col));+ if (bgHandled && borderHandled && this._stylesCache.fontMatrix.getValue(row, col)) {+ return;+ }+ }- if (isMerged) {- options.mergeRange = { startRow, startColumn, endRow, endColumn };+ const hasMergeData = options.hasMergeData ?? true;+ let isMerged = false;+ let isMergedMainCell = false;+ if (hasMergeData) {+ const mergeInfo = this.worksheet.getCellInfoInMergeData(row, col);+ isMerged = mergeInfo.isMerged;+ isMergedMainCell = mergeInfo.isMergedMainCell;+ if (isMerged) {+ const { startRow, startColumn, endRow, endColumn } = mergeInfo;+ options.mergeRange = { startRow, startColumn, endRow, endColumn };+ }}- const hidden = this.worksheet.getColVisible(col) === false || this.worksheet.getRowVisible(row) === false;+ const rowVisible = options.rowVisible ?? this.worksheet.getRowVisible(row);+ const hidden = this.worksheet.getColVisible(col) === false || rowVisible === false;// hidden and not in mergeRange return.if (hidden) {@@ -1517,7 +1687,7 @@ export class SpreadsheetSkeleton extends SheetSkeleton {this._setBgStylesCache(row, col, style, options);this._setBorderStylesCache(row, col, style, options);- this._setFontStylesCache(row, col, { ...cell, ...{ s: style } }, style);+ this._setFontStylesCache(row, col, { ...cell, ...{ s: style } }, style, options.hasMergeData ?? true);}/**diff --git a/packages/engine-render/src/components/sheets/spreadsheet.ts b/packages/engine-render/src/components/sheets/spreadsheet.tsindex 5eb758e44c..6f3a485159 100644--- a/packages/engine-render/src/components/sheets/spreadsheet.ts+++ b/packages/engine-render/src/components/sheets/spreadsheet.ts@@ -38,6 +38,138 @@ import { SheetComponent } from './sheet-component';const OBJECT_KEY = '__SHEET_EXTENSION_FONT_DOCUMENT_INSTANCE__';+interface ISparseExtensionFeatureFlags {+ hasCustomRender: boolean;+ hasMarkers: boolean;+ hasSelectionProtection: boolean;+ customRenderRanges: IRange[];+ markerRanges: IRange[];+ selectionProtectionRanges: IRange[];+}++function pushSparseCellRange(ranges: IRange[], row: number, col: number) {+ const last = ranges[ranges.length - 1];+ if (last && last.startRow === row && last.endRow === row && last.endColumn + 1 === col) {+ last.endColumn = col;+ return;+ }++ ranges.push({+ startRow: row,+ endRow: row,+ startColumn: col,+ endColumn: col,+ });+}++function scanSparseExtensionFeatures(spreadsheetSkeleton: SpreadsheetSkeleton, ranges: IRange[]): ISparseExtensionFeatureFlags | null {+ const { worksheet } = spreadsheetSkeleton;+ if (!worksheet || !ranges.length || worksheet.getMergeData().length > 0) {+ return null;+ }+ const flags: ISparseExtensionFeatureFlags = {+ hasCustomRender: false,+ hasMarkers: false,+ hasSelectionProtection: false,+ customRenderRanges: [],+ markerRanges: [],+ selectionProtectionRanges: [],+ };++ for (const range of ranges) {+ for (let row = range.startRow; row <= range.endRow; row++) {+ if (!worksheet.getRowVisible(row)) {+ continue;+ }++ for (let col = range.startColumn; col <= range.endColumn; col++) {+ if (!worksheet.getColVisible(col)) {+ continue;+ }++ const cachedCell = spreadsheetSkeleton.stylesCache.fontMatrix.getValue(row, col)?.cellData as Nullable<{+ customRender?: unknown[];+ markers?: unknown;+ selectionProtection?: unknown[];+ }>;+ const cell = cachedCell ?? (worksheet.getCell(row, col) as Nullable<{+ customRender?: unknown[];+ markers?: unknown;+ selectionProtection?: unknown[];+ }>);+ if (!cell) {+ continue;+ }++ if (cell.customRender?.length) {+ flags.hasCustomRender = true;+ pushSparseCellRange(flags.customRenderRanges, row, col);+ }+ if (cell.markers) {+ flags.hasMarkers = true;+ pushSparseCellRange(flags.markerRanges, row, col);+ }+ if (cell.selectionProtection?.length) {+ flags.hasSelectionProtection = true;+ pushSparseCellRange(flags.selectionProtectionRanges, row, col);+ }+ }+ }+ }++ return flags;+}++function shouldSkipSparseExtension(uKey: string, flags: ISparseExtensionFeatureFlags | null) {+ if (!flags) {+ return false;+ }++ switch (uKey) {+ case 'DefaultCustomExtension':+ return !flags.hasCustomRender;+ case 'DefaultMarkerExtension':+ return !flags.hasMarkers;+ case 'RANGE_PROTECTION_CAN_VIEW_RENDER_EXTENSION_KEY':+ case 'RANGE_PROTECTION_CAN_NOT_VIEW_RENDER_EXTENSION_KEY':+ return !flags.hasSelectionProtection;+ default:+ return false;+ }+}++function hasSparseExtension(extensions: Array<{ uKey: string }>) {+ return extensions.some((extension) => {+ switch (extension.uKey) {+ case 'DefaultCustomExtension':+ case 'DefaultMarkerExtension':+ case 'RANGE_PROTECTION_CAN_VIEW_RENDER_EXTENSION_KEY':+ case 'RANGE_PROTECTION_CAN_NOT_VIEW_RENDER_EXTENSION_KEY':+ return true;+ default:+ return false;+ }+ });+}++function getSparseExtensionDiffRanges(uKey: string, flags: ISparseExtensionFeatureFlags | null, diffRanges: IRange[]) {+ if (!flags) {+ return diffRanges;+ }++ switch (uKey) {+ case 'DefaultCustomExtension':+ return flags.customRenderRanges;+ case 'DefaultMarkerExtension':+ return flags.markerRanges;+ case 'RANGE_PROTECTION_CAN_VIEW_RENDER_EXTENSION_KEY':+ case 'RANGE_PROTECTION_CAN_NOT_VIEW_RENDER_EXTENSION_KEY':+ return flags.selectionProtectionRanges;+ default:+ return diffRanges;+ }+}+export class Spreadsheet extends SheetComponent {private _backgroundExtension!: Background;@@ -113,7 +245,8 @@ export class Spreadsheet extends SheetComponent {if (!spreadsheetSkeleton) {return;}- this._drawAuxiliary(ctx);+ const hasMergeData = spreadsheetSkeleton.worksheet.getMergeData().length > 0;+ this._drawAuxiliary(ctx, hasMergeData);const parentScale = this.getParentScale();const diffRanges = this._refreshIncrementalState && viewportInfo.diffBounds@@ -132,18 +265,28 @@ export class Spreadsheet extends SheetComponent {})): viewRanges;const extensions = this.getExtensionsByOrder();+ const sparseExtensionFeatures = !hasMergeData && hasSparseExtension(extensions)+ ? scanSparseExtensionFeatures(spreadsheetSkeleton, viewRanges)+ : null;// At this moment, ctx.transform is at topLeft of sheet content, cell(0, 0)const scene = this.getScene();for (const extension of extensions) {+ if (shouldSkipSparseExtension(extension.uKey, sparseExtensionFeatures)) {+ continue;+ }+const extensionViewRanges = extension === this._fontExtension || extension === this._borderExtension? overflowSafeViewRanges: viewRanges;+ const extensionDiffRanges = getSparseExtensionDiffRanges(extension.uKey, sparseExtensionFeatures, diffRanges);const timeKey = `${SHEET_EXTENSION_PREFIX}${extension.uKey}`;const st = Tools.now();- extension.draw(ctx, parentScale, spreadsheetSkeleton, diffRanges, {+ extension.draw(ctx, parentScale, spreadsheetSkeleton, extensionDiffRanges, {viewRanges: extensionViewRanges,checkOutOfViewBound: true,+ fontRenderRanges: extension === this._fontExtension ? spreadsheetSkeleton.incrementalFontRenderRanges : undefined,+ hasMergeData,viewportKey: viewportInfo.viewportKey,viewBound: viewportInfo.cacheBound,diffBounds: viewportInfo.diffBounds,@@ -252,7 +395,7 @@ export class Spreadsheet extends SheetComponent {}renderByViewports(mainCtx: UniverRenderingContext2D, viewportInfo: IViewportInfo, spreadsheetSkeleton: SpreadsheetSkeleton) {- const { diffBounds, diffX, diffY, viewPortPosition, cacheCanvas, leftOrigin, topOrigin, bufferEdgeX, bufferEdgeY, isDirty: isViewportDirty, isForceDirty: isViewportForceDirty } = viewportInfo as Required<IViewportInfo>;+ const { diffBounds, diffX, diffY, viewPortPosition, cacheCanvas, leftOrigin, topOrigin, bufferEdgeX, bufferEdgeY, isDirty: isViewportDirty, isForceDirty: isViewportForceDirty, shouldCacheUpdate } = viewportInfo as Required<IViewportInfo>;const { rowHeaderWidthAndMarginLeft, columnHeaderHeightAndMarginTop } = spreadsheetSkeleton;const { a: scaleX = 1, d: scaleY = 1 } = mainCtx.getTransform();const bufferEdgeSizeX = bufferEdgeX * scaleX / window.devicePixelRatio;@@ -263,10 +406,13 @@ export class Spreadsheet extends SheetComponent {const isForceDirty = isViewportForceDirty || this.isForceDirty();const isDirty = isViewportDirty || this.isDirty();+ const cachePixelRatio = cacheCanvas.getPixelRatio();const isScrollJumpOutsideCache =- Math.abs(diffX) * scaleX >= cacheCanvas.getWidth() ||- Math.abs(diffY) * scaleY >= cacheCanvas.getHeight();- const shouldRefreshCache = isDirty || isForceDirty || isScrollJumpOutsideCache;+ Math.abs(diffX) * scaleX >= cacheCanvas.getWidth() * cachePixelRatio ||+ Math.abs(diffY) * scaleY >= cacheCanvas.getHeight() * cachePixelRatio;+ const hasMergeData = spreadsheetSkeleton.worksheet.getMergeData().length > 0;+ const isScrolling = diffX !== 0 || diffY !== 0;+ const shouldRefreshCache = isDirty || isForceDirty || isScrollJumpOutsideCache || (hasMergeData && isScrolling) || (shouldCacheUpdate && diffX !== 0);if (diffBounds.length === 0 || (diffX === 0 && diffY === 0) || shouldRefreshCache) {if (shouldRefreshCache) {this.addRenderTagToScene('scrolling', false);@@ -386,6 +532,13 @@ export class Spreadsheet extends SheetComponent {if (!spreadsheetSkeleton) {return;}++ const { viewportKey } = viewportInfo;+ if (sheetHeaderViewportKeys.includes(viewportKey as SHEET_VIEWPORT_KEY)) {+ // Header viewports are rendered by row/column header components, not Spreadsheet.+ return this;+ }+spreadsheetSkeleton.setStylesCache(viewportInfo);const segment = spreadsheetSkeleton.rowColumnSegment;@@ -408,7 +561,6 @@ export class Spreadsheet extends SheetComponent {this.getScene()?.updateTransformerZero(rowHeaderWidthAndMarginLeft, columnHeaderHeightAndMarginTop);- const { viewportKey } = viewportInfo;// scene --> layer, getObjects --> viewport.render(object) --> spreadsheet// SHEET_COMPONENT_MAIN_LAYER_INDEX = 0;// SHEET_COMPONENT_SELECTION_LAYER_INDEX = 1;@@ -426,8 +578,6 @@ export class Spreadsheet extends SheetComponent {} else {this._draw(mainCtx, viewportInfo);}- } else if (sheetHeaderViewportKeys.includes(viewportKey as SHEET_VIEWPORT_KEY)) {- // doing nothing, other components(SpreadsheetRowHeader...) will render} else {// embed in doc & slide// now there are bugs in embed mode with cache on, 3f12ad80188a83283bcd95c65e6c5dcc2d23ad72@@ -544,7 +694,7 @@ export class Spreadsheet extends SheetComponent {* @param ctx*/// eslint-disable-next-line max-lines-per-function, complexity- private _drawAuxiliary(ctx: UniverRenderingContext2D) {+ private _drawAuxiliary(ctx: UniverRenderingContext2D, hasMergeData = true) {const spreadsheetSkeleton = this.getSkeleton();if (spreadsheetSkeleton == null) {return;@@ -606,25 +756,27 @@ export class Spreadsheet extends SheetComponent {//#region draw horizontal linesfor (let r = rowStart; r <= rowEnd; r++) {- if (worksheet.getRowVisible(r) === false) {- if (mergeVisibleRangeStartRow < r) {+ if (hasMergeData) {+ if (worksheet.getRowVisible(r) === false) {+ if (mergeVisibleRangeStartRow < r) {+ mergeVisibleRanges.push({+ startRow: mergeVisibleRangeStartRow,+ endRow: r - 1,+ startColumn,+ endColumn,+ });+ mergeVisibleRangeStartRow = r + 1;+ } else if (mergeVisibleRangeStartRow === r) {+ mergeVisibleRangeStartRow = r + 1;+ }+ } else if (r === endRow && mergeVisibleRangeStartRow <= r) {mergeVisibleRanges.push({startRow: mergeVisibleRangeStartRow,- endRow: r - 1,+ endRow: r,startColumn,endColumn,});- mergeVisibleRangeStartRow = r + 1;- } else if (mergeVisibleRangeStartRow === r) {- mergeVisibleRangeStartRow = r + 1;}- } else if (r === endRow && mergeVisibleRangeStartRow <= r) {- mergeVisibleRanges.push({- startRow: mergeVisibleRangeStartRow,- endRow: r,- startColumn,- endColumn,- });}if (r < 0 || r > rowHeightAccumulationLength - 1) {@@ -654,9 +806,11 @@ export class Spreadsheet extends SheetComponent {// clear line of merge cellconst mergeCellRanges: IRange[] = [];- for (const mergeVisibleRange of mergeVisibleRanges) {- const mergeRangeInVisible = spreadsheetSkeleton.getCurrentRowColumnSegmentMergeData(mergeVisibleRange);- mergeCellRanges.push(...mergeRangeInVisible);+ if (hasMergeData) {+ for (const mergeVisibleRange of mergeVisibleRanges) {+ const mergeRangeInVisible = spreadsheetSkeleton.getCurrentRowColumnSegmentMergeData(mergeVisibleRange);+ mergeCellRanges.push(...mergeRangeInVisible);+ }}this._clearRectangle(ctx, rowHeightAccumulation, columnWidthAccumulation, mergeCellRanges);diff --git a/packages/engine-render/src/shape/__tests__/scroll-bar.spec.ts b/packages/engine-render/src/shape/__tests__/scroll-bar.spec.tsindex 97b4b31c59..2ffae67c60 100644--- a/packages/engine-render/src/shape/__tests__/scroll-bar.spec.ts+++ b/packages/engine-render/src/shape/__tests__/scroll-bar.spec.ts@@ -153,13 +153,83 @@ describe('ScrollBar', () => {expect(scrollToBarPos).toHaveBeenCalledWith({ x: expect.any(Number) });expect(scrollToBarPos).toHaveBeenCalledWith({ y: expect.any(Number) });- expect(scrollByBarDeltaValue).toHaveBeenCalledWith({ x: 16 });- expect(scrollByBarDeltaValue).toHaveBeenCalledWith({ y: 24 });+ expect(scrollByBarDeltaValue).toHaveBeenCalledWith({ x: 16 }, true, { isBarDragEnd: true });+ expect(scrollByBarDeltaValue).toHaveBeenCalledWith({ y: 24 }, true, { isBarDragEnd: true });expect(setCapture).toHaveBeenCalled();scrollBar.dispose();});+ it('coalesces rapid thumb drag deltas before scrolling the viewport', () => {+ const scrollBar = new ScrollBar(viewport, { mainScene: scene });+ const scrollByBarDeltaValue = vi.spyOn(viewport, 'scrollByBarDeltaValue');+ const rafCallbacks: FrameRequestCallback[] = [];+ vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback: FrameRequestCallback) => {+ rafCallbacks.push(callback);+ return rafCallbacks.length;+ });+ vi.spyOn(window, 'cancelAnimationFrame').mockImplementation(() => {});++ scrollBar.resize(160, 120, 640, 480);+ scrollBar.verticalThumbRect!.onPointerDown$.emitEvent({ offsetX: 154, offsetY: 24 } as any);+ scene.onPointerMove$.emitEvent({ offsetX: 154, offsetY: 36 } as any);+ scene.onPointerMove$.emitEvent({ offsetX: 154, offsetY: 48 } as any);++ expect(scrollByBarDeltaValue).not.toHaveBeenCalled();+ expect(rafCallbacks).toHaveLength(1);++ rafCallbacks[0](16);++ expect(scrollByBarDeltaValue).toHaveBeenCalledOnce();+ expect(scrollByBarDeltaValue).toHaveBeenCalledWith({ y: 24 }, true, { isBarDragging: true });++ scrollBar.dispose();+ });++ it('throttles continued thumb drag scrolling while preserving the latest delta', () => {+ vi.useFakeTimers();+ try {+ const scrollBar = new ScrollBar(viewport, { mainScene: scene });+ const scrollByBarDeltaValue = vi.spyOn(viewport, 'scrollByBarDeltaValue');+ const rafCallbacks: FrameRequestCallback[] = [];+ vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback: FrameRequestCallback) => {+ rafCallbacks.push(callback);+ return rafCallbacks.length;+ });+ vi.spyOn(window, 'cancelAnimationFrame').mockImplementation(() => {});++ scrollBar.resize(160, 120, 640, 480);+ scrollBar.verticalThumbRect!.onPointerDown$.emitEvent({ offsetX: 154, offsetY: 24 } as any);+ scene.onPointerMove$.emitEvent({ offsetX: 154, offsetY: 36 } as any);+ scene.onPointerMove$.emitEvent({ offsetX: 154, offsetY: 48 } as any);++ rafCallbacks[0](16);+ expect(scrollByBarDeltaValue).toHaveBeenCalledOnce();+ expect(scrollByBarDeltaValue).toHaveBeenLastCalledWith({ y: 24 }, true, { isBarDragging: true });++ scene.onPointerMove$.emitEvent({ offsetX: 154, offsetY: 60 } as any);+ scene.onPointerMove$.emitEvent({ offsetX: 154, offsetY: 72 } as any);++ expect(rafCallbacks).toHaveLength(1);+ expect(scrollByBarDeltaValue).toHaveBeenCalledOnce();++ vi.advanceTimersByTime(32);+ expect(rafCallbacks).toHaveLength(2);++ rafCallbacks[1](48);+ expect(scrollByBarDeltaValue).toHaveBeenCalledTimes(2);+ expect(scrollByBarDeltaValue).toHaveBeenLastCalledWith({ y: 24 }, true, { isBarDragging: true });++ scene.onPointerUp$.emitEvent({ offsetX: 154, offsetY: 72 } as any);+ expect(scrollByBarDeltaValue).toHaveBeenCalledTimes(3);+ expect(scrollByBarDeltaValue).toHaveBeenLastCalledWith({ y: 0 }, true, { isBarDragEnd: true });++ scrollBar.dispose();+ } finally {+ vi.useRealTimers();+ }+ });+it('supports single-axis scrollbars and no-op resize guards', () => {const horizontalOnly = new ScrollBar(viewport, {enableHorizontal: true,diff --git a/packages/engine-render/src/shape/__tests__/text.spec.ts b/packages/engine-render/src/shape/__tests__/text.spec.tsindex 1bcec2837e..be4c6a657d 100644--- a/packages/engine-render/src/shape/__tests__/text.spec.ts+++ b/packages/engine-render/src/shape/__tests__/text.spec.ts@@ -136,6 +136,63 @@ describe('text shape', () => {expect(bottomCtx.beginPath).toHaveBeenCalled();});+ it('reuses simple text layouts for non-wrapped text', () => {+ const cache = (Text as any)._layoutCache as Map<string, unknown>;+ cache.clear();+ const firstCtx = createCtx();+ const secondCtx = createCtx();++ Text.drawWith(+ firstCtx,+ {+ text: 'repeat',+ fontStyle: '12px Arial',+ width: 100,+ height: 20,+ warp: false,+ hAlign: HorizontalAlign.LEFT,+ vAlign: VerticalAlign.TOP,+ } as any+ );+ Text.drawWith(+ secondCtx,+ {+ text: 'repeat',+ fontStyle: '12px Arial',+ width: 100,+ height: 20,+ warp: false,+ hAlign: HorizontalAlign.LEFT,+ vAlign: VerticalAlign.TOP,+ } as any+ );++ expect(cache.size).toBe(1);+ expect(firstCtx.fillText).toHaveBeenCalledTimes(1);+ expect(secondCtx.fillText).toHaveBeenCalledTimes(1);+ });++ it('draws plain cached text without nested context save and restore', () => {+ const ctx = createCtx();+ const height = Text.drawPlainWith(+ ctx,+ {+ text: '123',+ fontStyle: '12px Arial',+ width: 100,+ height: 20,+ hAlign: HorizontalAlign.RIGHT,+ vAlign: VerticalAlign.TOP,+ cellValueType: CellValueType.NUMBER,+ } as any+ );++ expect(height).toBeGreaterThanOrEqual(0);+ expect(ctx.save).not.toHaveBeenCalled();+ expect(ctx.restore).not.toHaveBeenCalled();+ expect(ctx.fillText.mock.calls[0][1]).toBeGreaterThanOrEqual(0);+ });+it('draws underline and strike line decorations', () => {const ctx = createCtx();const skeleton = createSkeleton([{ text: 'abc', width: 6, height: 10, baseline: 8 }]);diff --git a/packages/engine-render/src/shape/scroll-bar.ts b/packages/engine-render/src/shape/scroll-bar.tsindex 163e6d17d1..2ced170e85 100644--- a/packages/engine-render/src/shape/scroll-bar.ts+++ b/packages/engine-render/src/shape/scroll-bar.ts@@ -59,6 +59,7 @@ const DEFAULT_TRACK_SIZE = 10;const HOVER_TRACK_SIZE = 10;const DEFAULT_THUMB_MARGIN = 2;const HOVER_THUMB_MARGIN = 1;+const BAR_DRAG_SCROLL_THROTTLE_MS = 32;export class ScrollBar extends Disposable {_enableHorizontal: boolean = true;@@ -87,6 +88,11 @@ export class ScrollBar extends Disposable {private _isHorizonMove = false;private _isVerticalMove = false;+ private _pendingBarDeltaX = 0;+ private _pendingBarDeltaY = 0;+ private _pendingBarScrollFrameId: number | null = null;+ private _pendingBarScrollThrottleId: number | null = null;+private _horizonPointerMoveSub: Nullable<Subscription>;private _horizonPointerUpSub: Nullable<Subscription>;private _verticalPointerMoveSub: Nullable<Subscription>;@@ -330,6 +336,7 @@ export class ScrollBar extends Disposable {override dispose() {super.dispose();+ this._flushPendingBarScroll();this.horizonScrollTrack?.dispose();this.horizonThumbRect?.dispose();this.verticalScrollTrack?.dispose();@@ -351,6 +358,64 @@ export class ScrollBar extends Disposable {this._viewport.removeScrollBar();}+ private _scheduleBarScrollDelta(delta: Partial<{ x: number; y: number }>) {+ this._pendingBarDeltaX += delta.x ?? 0;+ this._pendingBarDeltaY += delta.y ?? 0;++ if (this._pendingBarScrollFrameId !== null || this._pendingBarScrollThrottleId !== null) {+ return;+ }++ this._requestPendingBarScrollFrame();+ }++ private _requestPendingBarScrollFrame() {+ this._pendingBarScrollFrameId = requestAnimationFrame(() => {+ this._pendingBarScrollFrameId = null;+ this._applyPendingBarScroll({ isBarDragging: true });++ if (!this._isHorizonMove && !this._isVerticalMove) {+ return;+ }++ this._pendingBarScrollThrottleId = window.setTimeout(() => {+ this._pendingBarScrollThrottleId = null;+ if (this._pendingBarDeltaX !== 0 || this._pendingBarDeltaY !== 0) {+ this._requestPendingBarScrollFrame();+ }+ }, BAR_DRAG_SCROLL_THROTTLE_MS);+ });+ }++ private _flushPendingBarScroll(isBarDragEnd = false) {+ if (this._pendingBarScrollFrameId !== null) {+ cancelAnimationFrame(this._pendingBarScrollFrameId);+ this._pendingBarScrollFrameId = null;+ }+ if (this._pendingBarScrollThrottleId !== null) {+ clearTimeout(this._pendingBarScrollThrottleId);+ this._pendingBarScrollThrottleId = null;+ }++ return this._applyPendingBarScroll({ isBarDragEnd });+ }++ private _applyPendingBarScroll(options?: { isBarDragging?: boolean; isBarDragEnd?: boolean }) {+ const x = this._pendingBarDeltaX;+ const y = this._pendingBarDeltaY;+ if (x === 0 && y === 0) {+ return false;+ }++ this._pendingBarDeltaX = 0;+ this._pendingBarDeltaY = 0;+ this._viewport.scrollByBarDeltaValue({+ ...(x === 0 ? null : { x }),+ ...(y === 0 ? null : { y }),+ }, true, options);+ return true;+ }+render(ctx: UniverRenderingContext, left: number = 0, top: number = 0) {const { scrollX, scrollY } = this._viewport;ctx.save();@@ -642,7 +707,7 @@ export class ScrollBar extends Disposable {if (!this._isVerticalMove) {return;}- this._viewport.scrollByBarDeltaValue({+ this._scheduleBarScrollDelta({y: e.offsetY - this._lastY,});@@ -651,7 +716,14 @@ export class ScrollBar extends Disposable {});this._verticalPointerUpSub = mainScene.onPointerUp$.subscribeEvent((_evt: unknown, _state: EventState) => {+ if (!this._isVerticalMove) {+ return;+ }const srcElement = this.verticalThumbRect;+ const hasPendingScroll = this._flushPendingBarScroll(true);+ if (!hasPendingScroll) {+ this._viewport.scrollByBarDeltaValue({ y: 0 }, true, { isBarDragEnd: true });+ }this._isVerticalMove = false;mainScene.releaseCapturedObject();mainScene.enableObjectsEvent();@@ -755,7 +827,7 @@ export class ScrollBar extends Disposable {if (!this._isHorizonMove) {return;}- this._viewport.scrollByBarDeltaValue({+ this._scheduleBarScrollDelta({x: e.offsetX - this._lastX,});this._lastX = e.offsetX;@@ -763,6 +835,13 @@ export class ScrollBar extends Disposable {});this._horizonPointerUpSub = mainScene.onPointerUp$.subscribeEvent((evt: unknown, state: EventState) => {;+ if (!this._isHorizonMove) {+ return;+ }+ const hasPendingScroll = this._flushPendingBarScroll(true);+ if (!hasPendingScroll) {+ this._viewport.scrollByBarDeltaValue({ x: 0 }, true, { isBarDragEnd: true });+ }this._isHorizonMove = false;mainScene.releaseCapturedObject();mainScene.enableObjectsEvent();diff --git a/packages/engine-render/src/shape/text.ts b/packages/engine-render/src/shape/text.tsindex 72d6a97792..0862f0edf1 100644--- a/packages/engine-render/src/shape/text.ts+++ b/packages/engine-render/src/shape/text.ts@@ -40,6 +40,12 @@ export interface ITextProps extends IShapeProps {export const TEXT_OBJECT_ARRAY = ['text', 'fontStyle', 'warp', 'hAlign', 'vAlign', 'width', 'height', 'color'];export class Text extends Shape<ITextProps> {+ private static readonly _MAX_LAYOUT_CACHE_SIZE = 5000;+ private static readonly _layoutCache = new Map<string, {+ lines: ReturnType<DocSimpleSkeleton['calculate']>;+ totalHeight: number;+ }>();+text: string;fontStyle: string;warp: boolean;@@ -68,9 +74,10 @@ export class Text extends Shape<ITextProps> {static override drawWith(ctx: UniverRenderingContext, props: ITextProps, _skeleton?: DocSimpleSkeleton) {const { text, fontStyle, warp, hAlign, vAlign, width, height, left = 0, top = 0, cellValueType } = props;- const skeleton = _skeleton ?? new DocSimpleSkeleton(text, fontStyle, Boolean(warp), width, vAlign === VerticalAlign.TOP ? height : Infinity);- const lines = skeleton.calculate();- const totalHeight = skeleton.getTotalHeight();+ const cachedLayout = !_skeleton && !warp ? Text._getCachedLayout(text, fontStyle) : null;+ const skeleton = cachedLayout ? null : _skeleton ?? new DocSimpleSkeleton(text, fontStyle, Boolean(warp), width, vAlign === VerticalAlign.TOP ? height : Infinity);+ const lines = cachedLayout?.lines ?? skeleton!.calculate();+ const totalHeight = cachedLayout?.totalHeight ?? skeleton!.getTotalHeight();const offsetY = vAlign === VerticalAlign.TOP ? 0 : vAlign === VerticalAlign.MIDDLE ? (height - totalHeight) / 2 : height - totalHeight;let lineTop = top + offsetY;@@ -142,6 +149,63 @@ export class Text extends Shape<ITextProps> {return totalHeight;}+ static drawPlainWith(ctx: UniverRenderingContext, props: ITextProps) {+ const { text, fontStyle, hAlign, vAlign, width, height, left = 0, top = 0, cellValueType } = props;+ const cachedLayout = Text._getCachedLayout(text, fontStyle);+ const { lines, totalHeight } = cachedLayout;+ const offsetY = vAlign === VerticalAlign.TOP ? 0 : vAlign === VerticalAlign.MIDDLE ? (height - totalHeight) / 2 : height - totalHeight;+ let lineTop = top + offsetY;++ ctx.font = fontStyle;+ ctx.fillStyle = props.color ?? COLOR_BLACK_RGB;++ for (const line of lines) {+ const lineWidth = line.width;+ let lineX = 0;+ if (!(width < lineWidth && cellValueType === CellValueType.NUMBER)) {+ switch (hAlign) {+ case HorizontalAlign.CENTER:+ lineX = (width - lineWidth) / 2;+ break;+ case HorizontalAlign.RIGHT:+ lineX = width - lineWidth;+ break;+ default:+ lineX = 0;+ }+ }++ ctx.fillText(line.text, left + lineX, lineTop + line.baseline);+ lineTop += line.height;+ }++ return totalHeight;+ }++ private static _getCachedLayout(text: string, fontStyle: string) {+ const cacheKey = `${fontStyle}\u0000${text}`;+ const cached = Text._layoutCache.get(cacheKey);+ if (cached) {+ return cached;+ }++ const skeleton = new DocSimpleSkeleton(text, fontStyle, false, 0, Infinity);+ const layout = {+ lines: skeleton.calculate(),+ totalHeight: skeleton.getTotalHeight(),+ };++ Text._layoutCache.set(cacheKey, layout);+ if (Text._layoutCache.size > Text._MAX_LAYOUT_CACHE_SIZE) {+ const oldestKey = Text._layoutCache.keys().next().value;+ if (oldestKey !== undefined) {+ Text._layoutCache.delete(oldestKey);+ }+ }++ return layout;+ }+/*** Draw text decoration lines (underline, strikethrough, etc.)*/diff --git a/packages/engine-render/src/viewport.ts b/packages/engine-render/src/viewport.tsindex 84f28cf868..391fc2d12d 100644--- a/packages/engine-render/src/viewport.ts+++ b/packages/engine-render/src/viewport.ts@@ -83,6 +83,13 @@ export interface IScrollObserverParam {limitX?: number;limitY?: number;isTrigger?: boolean;+ isBarDragging?: boolean;+ isBarDragEnd?: boolean;+}++interface IScrollByBarOptions {+ isBarDragging?: boolean;+ isBarDragEnd?: boolean;}interface IScrollBarPosition {@@ -549,10 +556,10 @@ export class Viewport {* @param delta* @returns isLimited*/- scrollByBarDeltaValue(delta: Partial<IScrollBarPosition>, isTrigger = true) {+ scrollByBarDeltaValue(delta: Partial<IScrollBarPosition>, isTrigger = true, options?: IScrollByBarOptions) {const x = this.scrollX + (delta.x || 0);const y = this.scrollY + (delta.y || 0);- return this._scrollToBarPosCore({ x, y }, isTrigger);+ return this._scrollToBarPosCore({ x, y }, isTrigger, options);}/**@@ -1286,7 +1293,7 @@ export class Viewport {* @param rawScrollXY Partial<IViewportScrollPosition>* @param isTrigger*/- private _scrollToBarPosCore(rawScrollXY: Partial<IScrollBarPosition>, isTrigger: boolean = true) {+ private _scrollToBarPosCore(rawScrollXY: Partial<IScrollBarPosition>, isTrigger: boolean = true, options?: IScrollByBarOptions) {if (this._scrollBar == null) {return;}@@ -1314,6 +1321,8 @@ export class Viewport {limitX: this._scrollBar?.limitX,limitY: this._scrollBar?.limitY,isTrigger,+ isBarDragging: options?.isBarDragging,+ isBarDragEnd: options?.isBarDragEnd,};this._scrollBar?.makeDirty(true);this.onScrollAfter$.emitEvent(scrollSubParam);@@ -1329,6 +1338,8 @@ export class Viewport {limitX: this._scrollBar?.limitX,limitY: this._scrollBar?.limitY,isTrigger,+ isBarDragging: options?.isBarDragging,+ isBarDragEnd: options?.isBarDragEnd,});return afterLimit;}@@ -1518,13 +1529,11 @@ export class Viewport {right: Math.min(prevBound.right, currBound.right),});}- const expandX = this.bufferEdgeX;- const expandY = this.bufferEdgeY;for (const bound of additionalAreas) {- bound.left = bound.left - expandX;- bound.right = bound.right + expandX;- bound.top = bound.top - expandY;- bound.bottom = bound.bottom + expandY;+ bound.left = bound.left - this.bufferEdgeX;+ bound.right = bound.right + this.bufferEdgeX;+ bound.top = bound.top - this.bufferEdgeY;+ bound.bottom = bound.bottom + this.bufferEdgeY;}return additionalAreas;diff --git a/packages/sheets-conditional-formatting-ui/src/controllers/__tests__/cf.render.controller.spec.ts b/packages/sheets-conditional-formatting-ui/src/controllers/__tests__/cf.render.controller.spec.tsindex ae26effe89..78efd1ac96 100644--- a/packages/sheets-conditional-formatting-ui/src/controllers/__tests__/cf.render.controller.spec.ts+++ b/packages/sheets-conditional-formatting-ui/src/controllers/__tests__/cf.render.controller.spec.ts@@ -14,6 +14,7 @@* limitations under the License.*/+import type { IRange } from '@univerjs/core';import { INTERCEPTOR_POINT } from '@univerjs/sheets';import { DEFAULT_PADDING, DEFAULT_WIDTH } from '@univerjs/sheets-conditional-formatting';import { Subject } from 'rxjs';@@ -24,12 +25,22 @@ afterEach(() => {vi.useRealTimers();});+interface ITestConditionFormattingRule {+ ranges: IRange[];+}+function createController() {let interceptor: any;const ruleChange$ = new Subject<any>();const markDirty$ = new Subject<any>();const reCalculate = vi.fn();const makeDirty = vi.fn();+ const resetRangeCache = vi.fn();+ const rowColumnSegment = { startRow: 0, endRow: 10, startColumn: 0, endColumn: 10 };+ const getRule = vi.fn<() => ITestConditionFormattingRule>(() => ({+ ranges: [{ startRow: 2, endRow: 4, startColumn: 1, endColumn: 3 }],+ }));+ const getSubunitRules = vi.fn<() => ITestConditionFormattingRule[]>(() => []);const controller = new SheetsCfRenderController({intercept: vi.fn((point, config) => {@@ -54,15 +65,15 @@ function createController() {} as never,{getRenderById: vi.fn(() => ({- with: vi.fn(() => ({ reCalculate })),+ with: vi.fn(() => ({ getCurrentSkeleton: vi.fn(() => ({ resetRangeCache, rowColumnSegment })), reCalculate })),mainComponent: { makeDirty },})),} as never,{ markDirty$ } as never,- { $ruleChange: ruleChange$ } as never+ { $ruleChange: ruleChange$, getRule, getSubunitRules } as never);- return { controller, interceptor: () => interceptor, ruleChange$, markDirty$, reCalculate, makeDirty };+ return { controller, getRule, getSubunitRules, interceptor: () => interceptor, markDirty$, makeDirty, reCalculate, resetRangeCache, rowColumnSegment, ruleChange$ };}describe('SheetsCfRenderController', () => {@@ -97,15 +108,58 @@ describe('SheetsCfRenderController', () => {it('marks the active sheet skeleton dirty when conditional formatting changes affect it', async () => {vi.useFakeTimers();- const { controller, ruleChange$, markDirty$, reCalculate, makeDirty } = createController();+ const { controller, ruleChange$, markDirty$, reCalculate, makeDirty, resetRangeCache } = createController();- ruleChange$.next({ unitId: 'unit-1', subUnitId: 'sheet-1' });+ const ranges = [{ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 }];+ ruleChange$.next({ unitId: 'unit-1', subUnitId: 'sheet-1', rule: { ranges } });markDirty$.next({ unitId: 'other-unit', subUnitId: 'sheet-1' });await vi.advanceTimersByTimeAsync(20);+ expect(resetRangeCache).toHaveBeenCalledWith(ranges);expect(reCalculate).toHaveBeenCalled();expect(makeDirty).toHaveBeenCalled();controller.dispose();});++ it('resets changed ranges found from conditional-formatting dirty cfIds', async () => {+ vi.useFakeTimers();+ const { controller, getRule, markDirty$, resetRangeCache, rowColumnSegment } = createController();++ markDirty$.next({ unitId: 'unit-1', subUnitId: 'sheet-1', cfId: 'cf-1' });+ await vi.advanceTimersByTimeAsync(20);++ expect(getRule).toHaveBeenCalledWith('unit-1', 'sheet-1', 'cf-1');+ expect(resetRangeCache).toHaveBeenCalledWith([{ startRow: 2, endRow: 4, startColumn: 1, endColumn: 3 }]);++ controller.dispose();+ });++ it('resets existing active-sheet rule ranges when the controller starts after snapshot rules are loaded', async () => {+ const { controller, getSubunitRules, resetRangeCache } = createController();+ const ranges = [{ startRow: 5, endRow: 6, startColumn: 2, endColumn: 4 }];+ getSubunitRules.mockReturnValue([{ ranges }]);++ await Promise.resolve();++ expect(getSubunitRules).toHaveBeenCalledWith('unit-1', 'sheet-1');+ expect(resetRangeCache).toHaveBeenCalledWith(ranges);++ controller.dispose();+ });++ it('clips large conditional-formatting dirty ranges to the current rendered range', async () => {+ vi.useFakeTimers();+ const { controller, getRule, markDirty$, resetRangeCache, rowColumnSegment } = createController();+ getRule.mockReturnValue({+ ranges: [{ startRow: 0, endRow: 20000, startColumn: 0, endColumn: 48 }],+ });++ markDirty$.next({ unitId: 'unit-1', subUnitId: 'sheet-1', cfId: 'cf-1' });+ await vi.advanceTimersByTimeAsync(20);++ expect(resetRangeCache).toHaveBeenCalledWith([rowColumnSegment]);++ controller.dispose();+ });});diff --git a/packages/sheets-conditional-formatting-ui/src/controllers/cf.render.controller.ts b/packages/sheets-conditional-formatting-ui/src/controllers/cf.render.controller.tsindex 81a1503fec..5cc9d1d55c 100644--- a/packages/sheets-conditional-formatting-ui/src/controllers/cf.render.controller.ts+++ b/packages/sheets-conditional-formatting-ui/src/controllers/cf.render.controller.ts@@ -14,7 +14,7 @@* limitations under the License.*/-import type { ICellDataForSheetInterceptor, Workbook } from '@univerjs/core';+import type { ICellDataForSheetInterceptor, IRange, Workbook } from '@univerjs/core';import type { IConditionalFormattingCellData, IConditionFormattingRule } from '@univerjs/sheets-conditional-formatting';import { Disposable, Inject, InterceptorEffectEnum, IUniverInstanceService, UniverInstanceType } from '@univerjs/core';import { IRenderManagerService } from '@univerjs/engine-render';@@ -49,15 +49,82 @@ export class SheetsCfRenderController extends Disposable {this._initViewModelInterceptor();this._initSkeleton();+ queueMicrotask(() => this._markActiveSheetRulesDirty());this.disposeWithMe(() => {this._ruleChangeCacheMap.clear();});}- private _markDirtySkeleton() {- const unitId = this._univerInstanceService.getCurrentUnitOfType<Workbook>(UniverInstanceType.UNIVER_SHEET)!.getUnitId();- this._renderManagerService.getRenderById(unitId)?.with(SheetSkeletonManagerService).reCalculate();- this._renderManagerService.getRenderById(unitId)?.mainComponent?.makeDirty();+ private _collectDirtyRanges(items: Array<{ cfId?: string; rule?: IConditionFormattingRule; subUnitId: string; unitId: string }>, unitId: string, subUnitId: string): IRange[] {+ const ranges: IRange[] = [];++ items.forEach((item) => {+ if (item.unitId !== unitId || item.subUnitId !== subUnitId) {+ return;+ }++ const rule = item.rule ?? (item.cfId ? this._conditionalFormattingRuleModel.getRule(unitId, subUnitId, item.cfId) : null);+ if (rule?.ranges?.length) {+ ranges.push(...rule.ranges);+ }+ });++ return ranges;+ }++ private _intersectDirtyRangesWithRenderedRange(ranges: IRange[], renderedRange?: IRange): IRange[] {+ if (!renderedRange || renderedRange.startRow < 0 || renderedRange.startColumn < 0) {+ return [];+ }++ return ranges.map((range) => ({+ startRow: Math.max(range.startRow, renderedRange.startRow),+ endRow: Math.min(range.endRow, renderedRange.endRow),+ startColumn: Math.max(range.startColumn, renderedRange.startColumn),+ endColumn: Math.min(range.endColumn, renderedRange.endColumn),+ })).filter((range) => range.startRow <= range.endRow && range.startColumn <= range.endColumn);+ }++ private _markDirtySkeleton(items: Array<{ cfId?: string; rule?: IConditionFormattingRule; subUnitId: string; unitId: string }>) {+ const workbook = this._univerInstanceService.getCurrentUnitOfType<Workbook>(UniverInstanceType.UNIVER_SHEET);+ const worksheet = workbook?.getActiveSheet();+ if (!workbook || !worksheet) {+ return;+ }++ const unitId = workbook.getUnitId();+ const subUnitId = worksheet.getSheetId();+ const render = this._renderManagerService.getRenderById(unitId);+ const skeletonManagerService = render?.with(SheetSkeletonManagerService);+ const currentSkeleton = skeletonManagerService?.getCurrentSkeleton();+ const dirtyRanges = this._intersectDirtyRangesWithRenderedRange(+ this._collectDirtyRanges(items, unitId, subUnitId),+ currentSkeleton?.rowColumnSegment+ );++ if (dirtyRanges.length) {+ currentSkeleton?.resetRangeCache(dirtyRanges);+ }++ skeletonManagerService?.reCalculate();+ render?.mainComponent?.makeDirty();+ }++ private _markActiveSheetRulesDirty() {+ const workbook = this._univerInstanceService.getCurrentUnitOfType<Workbook>(UniverInstanceType.UNIVER_SHEET);+ const worksheet = workbook?.getActiveSheet();+ if (!workbook || !worksheet) {+ return;+ }++ const unitId = workbook.getUnitId();+ const subUnitId = worksheet.getSheetId();+ const rules = this._conditionalFormattingRuleModel.getSubunitRules(unitId, subUnitId) ?? [];+ if (!rules.length) {+ return;+ }++ this._markDirtySkeleton(rules.map((rule) => ({ rule, subUnitId, unitId })));}private _initSkeleton() {@@ -74,7 +141,7 @@ export class SheetsCfRenderController extends Disposable {return v.some((item) => item.unitId === workbook.getUnitId() && item.subUnitId === worksheet.getSheetId());})- ).subscribe(() => this._markDirtySkeleton()));+ ).subscribe((items) => this._markDirtySkeleton(items)));}private _initViewModelInterceptor() {diff --git a/packages/sheets-ui/src/controllers/render-controllers/__tests__/scroll.render-controller.spec.ts b/packages/sheets-ui/src/controllers/render-controllers/__tests__/scroll.render-controller.spec.tsindex bd2da02d21..18ce292222 100644--- a/packages/sheets-ui/src/controllers/render-controllers/__tests__/scroll.render-controller.spec.ts+++ b/packages/sheets-ui/src/controllers/render-controllers/__tests__/scroll.render-controller.spec.ts@@ -140,6 +140,8 @@ describe('SheetsScrollRenderController', () => {expect(viewMain.limitedScroll).toHaveBeenCalledWith(0, 2);expect(preventDefault).toHaveBeenCalled();+ expect(viewMain.scrollY).toBe(-34);+ expect(viewMain.viewportScrollY).toBe(20);void controller;});@@ -233,6 +235,44 @@ describe('SheetsScrollRenderController', () => {void controller;});+ it('defers ScrollCommand for intermediate scrollbar drag events until drag end', () => {+ const scrollManagerService = createScrollManagerServiceMock();+ const testBed = createRenderTestBed({+ dependencies: [[SheetScrollManagerService, { useValue: scrollManagerService }]],+ });+ const { context, viewportMap } = testBed;+ const commandService = testBed.get(ICommandService);+ const executeSpy = vi.spyOn(commandService, 'executeCommand');++ const controller = testBed.injector.createInstance(SheetsScrollRenderController, context as any);+ const viewMain = viewportMap.get(SHEET_VIEWPORT_KEY.VIEW_MAIN) as any;++ viewMain.onScrollByBar$.emit({+ isTrigger: true,+ isBarDragging: true,+ viewportScrollX: 250,+ viewportScrollY: 45,+ }, {});++ expect(executeSpy).not.toHaveBeenCalledWith(ScrollCommand.id, expect.anything());++ viewMain.onScrollByBar$.emit({+ isTrigger: true,+ isBarDragEnd: true,+ viewportScrollX: 250,+ viewportScrollY: 45,+ }, {});++ expect(executeSpy).toHaveBeenCalledWith(ScrollCommand.id, {+ sheetViewStartRow: 2,+ sheetViewStartColumn: 2,+ offsetX: 50,+ offsetY: 5,+ });++ void controller;+ });+it('handles skeleton switch sync and raw scroll updates', () => {const scrollManagerService = createScrollManagerServiceMock();(scrollManagerService as any).getScrollStateByParam = vi.fn(() => ({diff --git a/packages/sheets-ui/src/controllers/render-controllers/mobile/mobile-scroll.render-controller.ts b/packages/sheets-ui/src/controllers/render-controllers/mobile/mobile-scroll.render-controller.tsindex c4bba0b6ac..22c05d4af0 100644--- a/packages/sheets-ui/src/controllers/render-controllers/mobile/mobile-scroll.render-controller.ts+++ b/packages/sheets-ui/src/controllers/render-controllers/mobile/mobile-scroll.render-controller.ts@@ -253,7 +253,7 @@ export class MobileSheetsScrollRenderController extends Disposable implements IRthis.disposeWithMe(viewportMain.onScrollByBar$.subscribeEvent((param) => {const skeleton = this._sheetSkeletonManagerService.getCurrentParam()?.skeleton;- if (skeleton == null || param.isTrigger === false) {+ if (skeleton == null || param.isTrigger === false || (param.isBarDragging && !param.isBarDragEnd)) {return;}diff --git a/packages/sheets-ui/src/controllers/render-controllers/scroll.render-controller.ts b/packages/sheets-ui/src/controllers/render-controllers/scroll.render-controller.tsindex 792033a51c..bcab5aa839 100644--- a/packages/sheets-ui/src/controllers/render-controllers/scroll.render-controller.ts+++ b/packages/sheets-ui/src/controllers/render-controllers/scroll.render-controller.ts@@ -235,7 +235,7 @@ export class SheetsScrollRenderController extends Disposable implements IRenderM// get scrollByBar event from viewport and exec ScrollCommand.id.viewportMain.onScrollByBar$.subscribeEvent((param) => {const skeleton = this._sheetSkeletonManagerService.getCurrentParam()?.skeleton;- if (skeleton == null || param.isTrigger === false) {+ if (skeleton == null || param.isTrigger === false || (param.isBarDragging && !param.isBarDragEnd)) {return;}