Skip to content

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

fix(sheets-ui): retain expanded editor size (#7854)

白熱90b74bffb9ff
diff --git a/packages/sheets-ui/src/services/editor/__tests__/cell-editor-resize.service.spec.ts b/packages/sheets-ui/src/services/editor/__tests__/cell-editor-resize.service.spec.ts
index eec66a5ec0..98c2bc8c1e 100644
--- a/packages/sheets-ui/src/services/editor/__tests__/cell-editor-resize.service.spec.ts
+++ b/packages/sheets-ui/src/services/editor/__tests__/cell-editor-resize.service.spec.ts
@@ -40,7 +40,8 @@ import { EditorService, IEditorService } from '@univerjs/docs-ui';
import { IRenderManagerService, RenderManagerService } from '@univerjs/engine-render';
import { SheetInterceptorService, SheetSkeletonService } from '@univerjs/sheets';
import { DesktopLayoutService, ILayoutService } from '@univerjs/ui';
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import { BehaviorSubject } from 'rxjs';
+import { afterEach, describe, expect, it, onTestFinished, vi } from 'vitest';
import { EditorBridgeService, IEditorBridgeService } from '../../editor-bridge.service';
import { EmbedFloatingGeometryService, ISheetEmbedFloatingGeometryService } from '../../sheet-embed-integration.service';
import { SheetSkeletonManagerService } from '../../sheet-skeleton-manager.service';
@@ -70,6 +71,8 @@ class TestCellEditorManagerService {
class TestEditorBridgeService {
refreshCount = 0;
+ readonly visible$ = new BehaviorSubject({ visible: true });
+
readonly editCellState = {
unitId: 'unit-1',
sheetId: 'sheet-1',
@@ -107,7 +110,7 @@ class TestEditorBridgeService {
}
isVisible() {
- return { visible: true };
+ return this.visible$.value;
}
refreshEditCellPosition() {
@@ -155,6 +158,8 @@ class TestUniverInstanceServiceWithDifferentCurrent extends TestUniverInstanceSe
}
class TestRenderManagerService {
+ readonly actualSize = { actualWidth: 120, actualHeight: 36 };
+
readonly sheetCanvasElement = {
style: { width: '800px' },
getBoundingClientRect: () => ({ left: 30, top: 50, width: 800, height: 600 }),
@@ -199,7 +204,7 @@ class TestRenderManagerService {
readonly docSkeleton = {
calculate: () => { },
resetInitialWidth: () => { },
- getActualSize: () => ({ actualWidth: 120, actualHeight: 36 }),
+ getActualSize: () => this.actualSize,
};
getRenderUnitById(unitId: string) {
@@ -286,11 +291,154 @@ class TestTransformedEmbedRenderManagerService extends TestRenderManagerService
};
}
+function createResizeTestInjector() {
+ const injector = new Injector();
+ onTestFinished(() => injector.dispose());
+ injector.add([ILayoutService, { useClass: TestLayoutService as never }]);
+ injector.add([ICellEditorManagerService, { useClass: TestCellEditorManagerService as never }]);
+ injector.add([IEditorBridgeService, { useClass: TestEditorBridgeService as never }]);
+ injector.add([IRenderManagerService, { useClass: TestRenderManagerService as never }]);
+ injector.add([IUniverInstanceService, { useClass: TestUniverInstanceService as never }]);
+ injector.add([IConfigService, { useClass: ConfigService }]);
+ injector.add([SheetCellEditorResizeService]);
+ return injector;
+}
+
describe('SheetCellEditorResizeService', () => {
afterEach(() => {
vi.unstubAllGlobals();
});
+ it.each([HorizontalAlign.LEFT, HorizontalAlign.CENTER, HorizontalAlign.RIGHT])('keeps the expanded editor size when deleting text with alignment %s', (alignment) => {
+ const injector = createResizeTestInjector();
+ const resizeService = injector.get(SheetCellEditorResizeService);
+ const bridge = injector.get(IEditorBridgeService) as unknown as TestEditorBridgeService;
+ const renderManager = injector.get(IRenderManagerService) as unknown as TestRenderManagerService;
+ const editorManager = injector.get(ICellEditorManagerService) as unknown as TestCellEditorManagerService;
+ bridge.editCellState.documentLayoutObject.horizontalAlign = alignment;
+
+ resizeService.fitTextSize();
+ const expandedState = editorManager.getState();
+ renderManager.actualSize.actualWidth = 12;
+ renderManager.actualSize.actualHeight = 16;
+ resizeService.fitTextSize();
+
+ expect(editorManager.getState()).toEqual(expandedState);
+ expect(renderManager.editorDocument.resized).toEqual({ width: 130, height: 44 });
+
+ renderManager.actualSize.actualWidth = 140;
+ renderManager.actualSize.actualHeight = 58;
+ resizeService.fitTextSize();
+ expect(renderManager.editorDocument.resized).toEqual({ width: 150, height: 66 });
+ });
+
+ it('starts a fresh size after the editor is closed and reopened', () => {
+ const injector = createResizeTestInjector();
+ const resizeService = injector.get(SheetCellEditorResizeService);
+ const bridge = injector.get(IEditorBridgeService) as unknown as TestEditorBridgeService;
+ const renderManager = injector.get(IRenderManagerService) as unknown as TestRenderManagerService;
+
+ resizeService.fitTextSize();
+ bridge.visible$.next({ visible: false });
+ renderManager.actualSize.actualWidth = 12;
+ renderManager.actualSize.actualHeight = 16;
+ bridge.visible$.next({ visible: true });
+ resizeService.fitTextSize();
+
+ expect(renderManager.editorDocument.resized).toEqual({ width: 60, height: 24 });
+ });
+
+ it('scales the retained size with worksheet zoom without inheriting viewport pixels', () => {
+ const injector = createResizeTestInjector();
+ const resizeService = injector.get(SheetCellEditorResizeService);
+ const bridge = injector.get(IEditorBridgeService) as unknown as TestEditorBridgeService;
+ const renderManager = injector.get(IRenderManagerService) as unknown as TestRenderManagerService;
+ const editorManager = injector.get(ICellEditorManagerService) as unknown as TestCellEditorManagerService;
+
+ resizeService.fitTextSize();
+ renderManager.actualSize.actualWidth = 12;
+ renderManager.actualSize.actualHeight = 16;
+ bridge.editCellState.scaleX = 0.5;
+ bridge.editCellState.scaleY = 0.5;
+ bridge.editCellState.position = { startX: 50, startY: 30, endX: 80, endY: 42 };
+ resizeService.fitTextSize();
+
+ expect(renderManager.editorDocument.resized).toEqual({ width: 130, height: 44 });
+ const state = editorManager.getState()!;
+ expect(Number(state.endX) - Number(state.startX)).toBe(65);
+ expect(Number(state.endY) - Number(state.startY)).toBe(22);
+ });
+
+ it('keeps wrapped content height without changing the cell wrapping width', () => {
+ const injector = createResizeTestInjector();
+ const resizeService = injector.get(SheetCellEditorResizeService);
+ const bridge = injector.get(IEditorBridgeService) as unknown as TestEditorBridgeService;
+ const renderManager = injector.get(IRenderManagerService) as unknown as TestRenderManagerService;
+ const instanceService = injector.get(IUniverInstanceService) as unknown as TestUniverInstanceService;
+ bridge.editCellState.documentLayoutObject.wrapStrategy = WrapStrategy.WRAP;
+ renderManager.actualSize.actualWidth = 50;
+ renderManager.actualSize.actualHeight = 70;
+
+ resizeService.fitTextSize();
+ renderManager.actualSize.actualWidth = 12;
+ renderManager.actualSize.actualHeight = 16;
+ resizeService.fitTextSize();
+
+ expect(renderManager.editorDocument.resized).toEqual({ width: 60, height: 78 });
+ expect(instanceService.documentModel.pageSize).toBe(60);
+ });
+
+ it('constrains the retained size to the viewport and restores it when space is available', () => {
+ const injector = createResizeTestInjector();
+ const resizeService = injector.get(SheetCellEditorResizeService);
+ const renderManager = injector.get(IRenderManagerService) as unknown as TestRenderManagerService;
+ const instanceService = injector.get(IUniverInstanceService) as unknown as TestUniverInstanceService;
+
+ resizeService.fitTextSize();
+ renderManager.actualSize.actualWidth = 12;
+ renderManager.actualSize.actualHeight = 16;
+ renderManager.sheetCanvasElement.style.width = '210px';
+ const bounds = vi.spyOn(renderManager.sheetCanvasElement, 'getBoundingClientRect')
+ .mockReturnValue({ left: 30, top: 50, width: 210, height: 88 });
+ resizeService.fitTextSize();
+
+ expect(renderManager.editorDocument.resized).toEqual({ width: 106, height: 24 });
+ expect(instanceService.documentModel.pageSize).toBe(106);
+
+ renderManager.sheetCanvasElement.style.width = '800px';
+ bounds.mockRestore();
+ resizeService.fitTextSize();
+ expect(renderManager.editorDocument.resized).toEqual({ width: 130, height: 44 });
+ });
+
+ it('does not repeatedly add scrollbar width or retain scrolling after deleting overflowing content', () => {
+ const injector = createResizeTestInjector();
+ const resizeService = injector.get(SheetCellEditorResizeService);
+ const renderManager = injector.get(IRenderManagerService) as unknown as TestRenderManagerService;
+ let hasScrollBar = true;
+ const scrollBar = {
+ barSize: 8,
+ dispose: () => { hasScrollBar = false; },
+ };
+ const viewport = {
+ getScrollBar: () => hasScrollBar ? scrollBar : null,
+ resetCanvasSizeAndUpdateScroll: () => {},
+ scrollToViewportPos: () => {},
+ };
+ vi.spyOn(renderManager.editorScene, 'getViewport').mockReturnValue(viewport as never);
+ renderManager.actualSize.actualHeight = 600;
+
+ resizeService.fitTextSize();
+ resizeService.fitTextSize();
+ expect(renderManager.editorDocument.resized).toEqual({ width: 138, height: 608 });
+
+ renderManager.actualSize.actualWidth = 12;
+ renderManager.actualSize.actualHeight = 16;
+ resizeService.fitTextSize();
+ expect(renderManager.editorDocument.resized).toEqual({ width: 138, height: 536 });
+ expect(hasScrollBar).toBe(false);
+ });
+
it('does not resize anything when no cell editor is active', () => {
vi.stubGlobal('window', new EventTarget());
vi.stubGlobal('document', { activeElement: { dataset: {} } });
diff --git a/packages/sheets-ui/src/services/editor/cell-editor-resize.service.ts b/packages/sheets-ui/src/services/editor/cell-editor-resize.service.ts
index 7bdb4f0ac5..5adfb64808 100644
--- a/packages/sheets-ui/src/services/editor/cell-editor-resize.service.ts
+++ b/packages/sheets-ui/src/services/editor/cell-editor-resize.service.ts
@@ -54,6 +54,10 @@ interface ICanvasOffset {
}
export class SheetCellEditorResizeService extends Disposable {
+ private _editorWidth = 0;
+
+ private _editorHeight = 0;
+
constructor(
@ILayoutService private readonly _layoutService: ILayoutService,
@ICellEditorManagerService private readonly _cellEditorManagerService: ICellEditorManagerService,
@@ -64,6 +68,13 @@ export class SheetCellEditorResizeService extends Disposable {
@Optional(ISheetEmbedFloatingGeometryService) private readonly _embedFloatingGeometryService?: ISheetEmbedFloatingGeometryService
) {
super();
+
+ this.disposeWithMe(this._editorBridgeService.visible$.subscribe(({ visible }) => {
+ if (!visible) {
+ this._editorWidth = 0;
+ this._editorHeight = 0;
+ }
+ }));
}
private get _currentRenderer() {
@@ -121,15 +132,12 @@ export class SheetCellEditorResizeService extends Disposable {
const { verticalAlign, horizontalAlign, paddingData, fill } = documentLayoutObject;
actualWidth = actualWidth + (paddingData.l ?? 0) * scaleX + (paddingData.r ?? 0) * scaleX;
actualHeight = actualHeight + (paddingData.t ?? 0) * scaleY + (paddingData.b ?? 0) * scaleY;
- let editorWidth = endX - startX;
- let editorHeight = endY - startY;
- if (editorWidth < actualWidth) {
- editorWidth = Math.ceil(actualWidth);
- }
-
- if (editorHeight < actualHeight) {
- editorHeight = Math.ceil(actualHeight);
- }
+ const cellWidth = endX - startX;
+ const cellHeight = endY - startY;
+ const contentWidth = cellWidth < actualWidth ? Math.ceil(actualWidth) : cellWidth;
+ const contentHeight = cellHeight < actualHeight ? Math.ceil(actualHeight) : cellHeight;
+ const editorWidth = Math.max(contentWidth, Math.min(this._editorWidth * scaleX, info.maxSize.width));
+ const editorHeight = Math.max(contentHeight, Math.min(this._editorHeight * scaleY, info.maxSize.height));
// Set the top margin under vertical alignment.
let offsetTop = 0;
@@ -144,11 +152,9 @@ export class SheetCellEditorResizeService extends Disposable {
}
let offsetLeft = 0;
- if (horizontalAlign === HorizontalAlign.CENTER) {
- // offsetLeft = ((editorWidth - actualWidth) / 2 / scaleX);
- } else if (horizontalAlign === HorizontalAlign.RIGHT) {
+ if (horizontalAlign === HorizontalAlign.RIGHT) {
offsetLeft = (editorWidth - actualWidth) / scaleX;
- } else {
+ } else if (horizontalAlign !== HorizontalAlign.CENTER) {
offsetLeft = paddingData.l || 0;
}
offsetTop = Math.max(offsetTop, paddingData.t || 0);
@@ -160,8 +166,7 @@ export class SheetCellEditorResizeService extends Disposable {
documentSkeleton.calculate();
this._editAreaProcessing(
- editorWidth,
- editorHeight,
+ { width: editorWidth, height: editorHeight, contentWidth },
position,
canvasOffset,
fill,
@@ -192,6 +197,8 @@ export class SheetCellEditorResizeService extends Disposable {
const documentDataModel = this._univerInstanceService.getUnit<DocumentDataModel>(DOCS_NORMAL_EDITOR_UNIT_ID_KEY, UniverInstanceType.UNIVER_DOC);
const { vertexAngle: angle } = convertTextRotation(textRotation);
+ const maxSize = this._getEditorMaxSize(actualRangeWithCoord, canvasOffset, documentLayoutObject.horizontalAlign);
+ if (!maxSize) return;
if (wrapStrategy === WrapStrategy.WRAP && angle === 0) {
documentDataModel?.updateDocumentDataPageSize((endX - startX) / scaleX);
@@ -202,16 +209,15 @@ export class SheetCellEditorResizeService extends Disposable {
return {
actualWidth: actualWidth * scaleX,
actualHeight: actualHeight * scaleY,
+ maxSize,
};
}
- const maxSize = this._getEditorMaxSize(actualRangeWithCoord, canvasOffset, documentLayoutObject.horizontalAlign);
- if (!maxSize) return;
documentDataModel?.updateDocumentDataPageSize(maxSize.width / scaleX);
documentSkeleton.calculate();
const size = documentSkeleton.getActualSize();
- let editorWidth = endX - startX;
+ let editorWidth = Math.max(endX - startX, Math.min(this._editorWidth * scaleX, maxSize.width));
if (editorWidth < size.actualWidth * scaleX + EDITOR_INPUT_SELF_EXTEND_GAP * scaleX) {
editorWidth = size.actualWidth * scaleX + EDITOR_INPUT_SELF_EXTEND_GAP * scaleX;
@@ -231,6 +237,7 @@ export class SheetCellEditorResizeService extends Disposable {
return {
actualWidth: size.actualWidth * scaleX,
actualHeight: size.actualHeight * scaleY,
+ maxSize,
};
}
@@ -292,10 +299,8 @@ export class SheetCellEditorResizeService extends Disposable {
* determine whether a scrollbar appears,
* and calculate the editor's boundaries relative to the browser.
*/
- // eslint-disable-next-line max-lines-per-function
private _editAreaProcessing(
- editorWidth: number,
- editorHeight: number,
+ size: { width: number; height: number; contentWidth: number },
actualRangeWithCoord: IPosition,
canvasOffset: ICanvasOffset,
fill: Nullable<string>,
@@ -317,37 +322,15 @@ export class SheetCellEditorResizeService extends Disposable {
let { startX, startY } = actualRangeWithCoord;
const { document: documentComponent, scene: editorScene, engine: docEngine } = editorObject;
- const viewportMain = editorScene.getViewport(VIEWPORT_KEY.VIEW_MAIN);
-
const info = this._getEditorMaxSize(actualRangeWithCoord, canvasOffset, horizontalAlign)!;
-
const { height: clientHeight, width: clientWidth, contentScaleX, contentScaleY, scaleAdjustX, scaleAdjustY } = info;
+ const { physicHeight, scrollBarWidth } = this._fitEditorViewport(editorScene, size.height, clientHeight);
+ const editorWidth = Math.min(Math.max(size.width, size.contentWidth + scrollBarWidth), clientWidth);
+ const editorHeight = size.height;
- let physicHeight = editorHeight;
-
- let scrollBar = viewportMain?.getScrollBar() as Nullable<ScrollBar>;
-
- if (physicHeight > clientHeight) {
- if (scrollBar == null) {
- viewportMain && new ScrollBar(viewportMain, { enableHorizontal: false, barSize: 8 });
- } else {
- viewportMain?.resetCanvasSizeAndUpdateScroll();
- }
- viewportMain?.scrollToViewportPos({
- viewportScrollY: physicHeight - clientHeight,
- });
-
- physicHeight = clientHeight;
- } else {
- scrollBar = null;
- viewportMain?.getScrollBar()?.dispose();
- }
-
- editorWidth += scrollBar?.barSize || 0;
-
- if (editorWidth > clientWidth) {
- editorWidth = clientWidth;
- }
+ // Keep the visible extent for this edit only; skeleton measurements must still discard stale layout width.
+ this._editorWidth = Math.max(this._editorWidth, editorWidth / scaleX);
+ this._editorHeight = Math.max(this._editorHeight, physicHeight / scaleY);
this._addBackground(editorScene, editorWidth / scaleX, editorHeight / scaleY, fill);
@@ -362,11 +345,7 @@ export class SheetCellEditorResizeService extends Disposable {
documentComponent.resize(editorWidth * scaleAdjustX / scaleX, editorHeight * scaleAdjustY / scaleY);
- /**
- * sometimes requestIdleCallback is invalid, so use setTimeout to ensure the successful execution of the resizeBySize method.
- * resize canvas
- * When modifying the selection area for a formula, it is necessary to add a setTimeout to ensure successful updating.
- */
+ // Defer canvas resizing until formula selections have updated the render scene.
setTimeout(() => {
docEngine.resizeBySize(
fixLineWidthByScale(editorWidth, precisionScaleX),
@@ -398,6 +377,28 @@ export class SheetCellEditorResizeService extends Disposable {
});
}
+ private _fitEditorViewport(editorScene: Scene, editorHeight: number, clientHeight: number) {
+ const viewportMain = editorScene.getViewport(VIEWPORT_KEY.VIEW_MAIN);
+ let scrollBar = viewportMain?.getScrollBar() as Nullable<ScrollBar>;
+
+ if (editorHeight > clientHeight) {
+ if (scrollBar == null) {
+ viewportMain && new ScrollBar(viewportMain, { enableHorizontal: false, barSize: 8 });
+ } else {
+ viewportMain?.resetCanvasSizeAndUpdateScroll();
+ }
+ viewportMain?.scrollToViewportPos({ viewportScrollY: editorHeight - clientHeight });
+ } else {
+ scrollBar = null;
+ viewportMain?.getScrollBar()?.dispose();
+ }
+
+ return {
+ physicHeight: Math.min(editorHeight, clientHeight),
+ scrollBarWidth: scrollBar?.barSize ?? 0,
+ };
+ }
+
private _getEditorContentElement(): HTMLElement {
return this._embedFloatingGeometryService
?.getRegistrationByChildUnitId(this._editingUnitId)