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-drawing): tolerate invalid placements during replay (#7933)

wpxp123456dc6ca7c75160
diff --git a/packages/core/src/sheets/__tests__/sheet-skeleton.integration.spec.ts b/packages/core/src/sheets/__tests__/sheet-skeleton.integration.spec.ts
index fb97200db8..c7c1196f15 100644
--- a/packages/core/src/sheets/__tests__/sheet-skeleton.integration.spec.ts
+++ b/packages/core/src/sheets/__tests__/sheet-skeleton.integration.spec.ts
@@ -14,10 +14,10 @@
* limitations under the License.
*/
+import { afterEach, describe, expect, it } from 'vitest';
import type { Injector } from '../../common/di';
import type { IDocumentData, IDocumentRenderConfig, IPaddingData } from '../../types/interfaces';
import type { IWorkbookData } from '../typedef';
-import { afterEach, describe, expect, it } from 'vitest';
import { IConfigService } from '../../services/config/config.service';
import { IContextService } from '../../services/context/context.service';
import { LocaleService } from '../../services/locale/locale.service';
@@ -217,6 +217,29 @@ describe('SheetSkeleton integration', () => {
expect(skeleton.getColumnIndexByOffsetX(382, 1, { x: 0, y: 0 }, { firstMatch: true })).toBe(5);
});
+ it('resolves model positions independently of the viewport while preserving default viewport lookup', () => {
+ const testBed = createCoreTestBed(workbookDataFactory());
+ const injector = testBed.univer.__getInjector();
+ const worksheet = testBed.sheet.getActiveSheet()!;
+ const createSkeleton = () => injector.createInstance(SheetSkeleton, worksheet, testBed.sheet.getStyles());
+ injector.add([SheetSkeleton, { useFactory: createSkeleton }]);
+ const skeleton = injector.get(SheetSkeleton);
+ skeleton.calculate();
+ disposables.push(() => {
+ skeleton.dispose();
+ testBed.univer.dispose();
+ });
+ const expected = skeleton.getCellIndexAndOffsetByPosition(150, 60, 1, 1, { x: 0, y: 0 });
+ skeleton.setScroll(24, 12);
+ skeleton.setScale(2);
+ expect(skeleton.getCellIndexAndOffsetByPosition(150, 60, 1, 1, { x: 0, y: 0 })).toEqual(expected);
+ const viewportCell = skeleton.getCellWithCoordByOffset(252, 96, 2, 2, { x: 24, y: 12 });
+ expect(skeleton.getCellIndexAndOffsetByPosition(252, 96)).toMatchObject({
+ row: viewportCell.actualRow,
+ column: viewportCell.actualColumn,
+ });
+ });
+
it('should compute overflow bounds and document render config through the real skeleton instance', () => {
const testBed = createCoreTestBed(workbookDataFactory());
const injector = testBed.univer.__getInjector();
diff --git a/packages/core/src/sheets/sheet-skeleton.ts b/packages/core/src/sheets/sheet-skeleton.ts
index d7f58fc134..3da951b210 100644
--- a/packages/core/src/sheets/sheet-skeleton.ts
+++ b/packages/core/src/sheets/sheet-skeleton.ts
@@ -15,6 +15,7 @@
*/
/* eslint-disable no-param-reassign */
+import { Subject } from 'rxjs';
import type { IObjectArrayPrimitiveType, Nullable } from '../shared';
import type {
IDocumentData,
@@ -34,7 +35,6 @@ import type {
IWorksheetData,
} from './typedef';
import type { Worksheet } from './worksheet';
-import { Subject } from 'rxjs';
import { AUTO_HEIGHT_FOR_MERGED_CELLS, IS_ROW_STYLE_PRECEDE_COLUMN_STYLE } from '../common/const';
import { Inject, Injector } from '../common/di';
import { DocumentDataModel } from '../docs/data-model/document-data-model';
@@ -1115,11 +1115,15 @@ export class SheetSkeleton extends Skeleton {
}
/**
- * Here, offsetX and offsetY are the coordinates in the viewport, including the rowHeaderWidthAndMarginLeft and columnHeaderHeightAndMarginTop.
+ * Coordinates include the row and column headers. Defaults to the current viewport transform;
+ * pass unit scales and zero scroll for Sheet model coordinates.
*/
getCellIndexAndOffsetByPosition(
offsetX: number,
- offsetY: number
+ offsetY: number,
+ scaleX: number = this._scaleX,
+ scaleY: number = this._scaleY,
+ scrollXY: { x: number; y: number } = { x: this._scrollX, y: this._scrollY }
): {
row: number;
rowOffset: number;
@@ -1129,12 +1133,9 @@ export class SheetSkeleton extends Skeleton {
const { actualRow, actualColumn, startX, startY } = this.getCellWithCoordByOffset(
offsetX,
offsetY,
- this._scaleX,
- this._scaleY,
- {
- x: this._scrollX,
- y: this._scrollY,
- }
+ scaleX,
+ scaleY,
+ scrollXY
);
return {
diff --git a/packages/sheets-drawing-ui/src/controllers/render-controllers/__tests__/sheet-drawing.render-controller.spec.ts b/packages/sheets-drawing-ui/src/controllers/render-controllers/__tests__/sheet-drawing.render-controller.spec.ts
index e7334b4c6d..d13e3b0eb2 100644
--- a/packages/sheets-drawing-ui/src/controllers/render-controllers/__tests__/sheet-drawing.render-controller.spec.ts
+++ b/packages/sheets-drawing-ui/src/controllers/render-controllers/__tests__/sheet-drawing.render-controller.spec.ts
@@ -16,12 +16,12 @@
import type { ISheetDrawing } from '@univerjs/sheets-drawing';
import type { Subscription } from 'rxjs';
-import { DrawingTypeEnum, LocaleType, Tools, UniverInstanceType } from '@univerjs/core';
+import { DrawingTypeEnum, ILogService, LocaleType, LogLevel, Tools, UniverInstanceType } from '@univerjs/core';
import { FUniver } from '@univerjs/core/facade';
import { IDrawingManagerService } from '@univerjs/drawing';
import { CanvasColorService, ICanvasColorService, IRenderManagerService } from '@univerjs/engine-render';
-import { SetWorksheetRowAutoHeightMutation, SheetSkeletonService } from '@univerjs/sheets';
-import { ISheetDrawingService, SheetDrawingAnchorType } from '@univerjs/sheets-drawing';
+import { SetRangeValuesCommand, SetWorksheetRowAutoHeightMutation, SheetSkeletonService } from '@univerjs/sheets';
+import { ISheetDrawingService, SHEET_DRAWING_PLUGIN, SheetDrawingAnchorType } from '@univerjs/sheets-drawing';
import { describe, expect, it, vi } from 'vitest';
import { createSheetsDrawingUiTestBed } from '../../../__tests__/create-sheets-drawing-ui-test-bed';
import { SheetsDrawingRenderController } from '../sheet-drawing.render-controller';
@@ -29,6 +29,99 @@ import '@univerjs/sheets/facade';
import '@univerjs/sheets-drawing/facade';
describe('SheetsDrawingRenderController', () => {
+ it('loads issue 5842 data, initializes healthy images, and preserves edits across save and reload', async () => {
+ const canvasContext = vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockReturnValue(
+ { setTransform: vi.fn(), clearRect: vi.fn() } as unknown as CanvasRenderingContext2D
+ );
+ const warning = vi.spyOn(console, 'warn').mockImplementation(() => {});
+ const source = createSheetsDrawingUiTestBed();
+ let restored: ReturnType<typeof createSheetsDrawingUiTestBed> | undefined;
+ let reloaded: ReturnType<typeof createSheetsDrawingUiTestBed> | undefined;
+ try {
+ const snapshot = FUniver.newAPI(source.univer).getActiveWorkbook()!.save();
+ snapshot.sheets.sheet1.rowCount = 300;
+ const from = { column: 3, columnOffset: 0, row: 198, rowOffset: -4460 };
+ const to = { column: 4, columnOffset: 60.3, row: -2, rowOffset: 0 };
+ const broken: ISheetDrawing = {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ drawingId: 'broken-image',
+ drawingType: DrawingTypeEnum.DRAWING_IMAGE,
+ anchorType: SheetDrawingAnchorType.Position,
+ transform: { left: 300, top: -4243, width: 180.3, height: -4243, angle: 0 },
+ sheetTransform: { from, to, angle: 0 },
+ axisAlignSheetTransform: { from, to, angle: 0 },
+ };
+ const healthy: ISheetDrawing = {
+ ...broken,
+ drawingId: 'healthy-image',
+ transform: { left: 999, top: 999, width: 120, height: 80, angle: 0 },
+ sheetTransform: {
+ from: { row: 1, column: 1, rowOffset: 0, columnOffset: 0 },
+ to: { row: 4, column: 2, rowOffset: 8, columnOffset: 20 },
+ angle: 0,
+ },
+ };
+ snapshot.resources = (snapshot.resources ?? []).filter((resource) => resource.name !== SHEET_DRAWING_PLUGIN);
+ snapshot.resources.push({ name: SHEET_DRAWING_PLUGIN, data: JSON.stringify({
+ sheet1: {
+ data: { [broken.drawingId]: broken, [healthy.drawingId]: healthy },
+ order: [broken.drawingId, healthy.drawingId],
+ },
+ }) });
+ restored = createSheetsDrawingUiTestBed(snapshot, [[ICanvasColorService, { useClass: CanvasColorService }]]);
+ restored.get(ILogService).setLogLevel(LogLevel.WARN);
+ const skeleton = restored.get(SheetSkeletonService).ensureSkeleton('test', 'sheet1')!;
+ const manager = restored.get(IRenderManagerService);
+ manager.registerRenderModule(UniverInstanceType.UNIVER_SHEET, [SheetsDrawingRenderController]);
+ expect(() => manager.createRender('test').with(SheetsDrawingRenderController)).not.toThrow();
+ expect(warning).toHaveBeenCalledWith(expect.stringContaining('[SheetsDrawingRenderController]'), expect.any(String), expect.objectContaining({
+ drawingId: broken.drawingId,
+ error: expect.any(Error),
+ }));
+ const drawings = restored.get(ISheetDrawingService);
+ const renderDrawings = restored.get(IDrawingManagerService);
+ expect(drawings.getDrawingByParam(broken)).toEqual(broken);
+ expect(renderDrawings.getDrawingByParam(broken)).toEqual(broken);
+ const cell = skeleton.getNoMergeCellWithCoordByIndex(1, 1);
+ expect(drawings.getDrawingByParam(healthy)?.transform).toMatchObject({
+ left: cell.startX,
+ top: cell.startY,
+ width: 120,
+ height: 80,
+ });
+ expect(renderDrawings.getDrawingByParam(healthy)).toEqual(drawings.getDrawingByParam(healthy));
+ expect(restored.commandService.syncExecuteCommand(SetWorksheetRowAutoHeightMutation.id, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ rowsAutoHeightInfo: [{ row: 80, autoHeight: 40 }],
+ })).toBe(true);
+ await Promise.resolve();
+ expect(await restored.commandService.executeCommand(SetRangeValuesCommand.id, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ range: { startRow: 80, endRow: 80, startColumn: 0, endColumn: 0 },
+ value: { v: 'edited after replay' },
+ })).toBe(true);
+ reloaded = createSheetsDrawingUiTestBed(FUniver.newAPI(restored.univer).getActiveWorkbook()!.save(), [
+ [ICanvasColorService, { useClass: CanvasColorService }],
+ ]);
+ reloaded.get(SheetSkeletonService).ensureSkeleton('test', 'sheet1');
+ const reloadedManager = reloaded.get(IRenderManagerService);
+ reloadedManager.registerRenderModule(UniverInstanceType.UNIVER_SHEET, [SheetsDrawingRenderController]);
+ expect(() => reloadedManager.createRender('test').with(SheetsDrawingRenderController)).not.toThrow();
+ expect(reloaded.workbook.getSheetBySheetId('sheet1')!.getCell(80, 0)?.v).toBe('edited after replay');
+ expect(reloaded.get(ISheetDrawingService).getDrawingByParam(broken)).toEqual(broken);
+ expect(reloaded.get(ISheetDrawingService).getDrawingByParam(healthy)).toEqual(drawings.getDrawingByParam(healthy));
+ } finally {
+ reloaded?.univer.dispose();
+ restored?.univer.dispose();
+ source.univer.dispose();
+ warning.mockRestore();
+ canvasContext.mockRestore();
+ }
+ });
+
it.each([
['row', SheetDrawingAnchorType.Position],
['column', SheetDrawingAnchorType.Position],
diff --git a/packages/sheets-drawing-ui/src/controllers/render-controllers/sheet-drawing.render-controller.ts b/packages/sheets-drawing-ui/src/controllers/render-controllers/sheet-drawing.render-controller.ts
index 1db7f7e4aa..7d9ea8c6b1 100644
--- a/packages/sheets-drawing-ui/src/controllers/render-controllers/sheet-drawing.render-controller.ts
+++ b/packages/sheets-drawing-ui/src/controllers/render-controllers/sheet-drawing.render-controller.ts
@@ -16,7 +16,7 @@
import type { IRenderContext, IRenderModule } from '@univerjs/engine-render';
import type { ISheetDrawing } from '@univerjs/sheets-drawing';
-import { Disposable, DrawingTypeEnum, Inject } from '@univerjs/core';
+import { Disposable, DrawingTypeEnum, ILogService, Inject } from '@univerjs/core';
import { IDrawingManagerService } from '@univerjs/drawing';
import { SheetSkeletonService } from '@univerjs/sheets';
import {
@@ -31,7 +31,8 @@ export class SheetsDrawingRenderController extends Disposable implements IRender
private _context: IRenderContext,
@ISheetDrawingService private readonly _sheetDrawingService: ISheetDrawingService,
@IDrawingManagerService private readonly _drawingManagerService: IDrawingManagerService,
- @Inject(SheetSkeletonService) private readonly _sheetSkeletonService: SheetSkeletonService
+ @Inject(SheetSkeletonService) private readonly _sheetSkeletonService: SheetSkeletonService,
+ @ILogService private readonly _logService: ILogService
) {
super();
@@ -60,18 +61,29 @@ export class SheetsDrawingRenderController extends Disposable implements IRender
!drawingData.groupId &&
drawingData.anchorType !== SheetDrawingAnchorType.None
) {
- if (drawingData.drawingType === DrawingTypeEnum.DRAWING_GROUP) {
- const transform = drawingPositionToTransform(drawingData.sheetTransform, skeletonParam);
- refreshedDrawings.push({
- ...drawingData,
- transform: transform && {
- ...transform,
- left: (transform.left ?? 0) - skeletonParam.skeleton.rowHeaderWidthAndMarginLeft,
- top: (transform.top ?? 0) - skeletonParam.skeleton.columnHeaderHeightAndMarginTop,
- },
+ try {
+ if (drawingData.drawingType === DrawingTypeEnum.DRAWING_GROUP) {
+ const transform = drawingPositionToTransform(drawingData.sheetTransform, skeletonParam);
+ refreshedDrawings.push({
+ ...drawingData,
+ transform: transform && {
+ ...transform,
+ left: (transform.left ?? 0) - skeletonParam.skeleton.rowHeaderWidthAndMarginLeft,
+ top: (transform.top ?? 0) - skeletonParam.skeleton.columnHeaderHeightAndMarginTop,
+ },
+ });
+ } else {
+ refreshedDrawings.push(refreshSheetDrawingPlacement(drawingData, skeletonParam.skeleton));
+ }
+ } catch (error) {
+ this._logService.warn('[SheetsDrawingRenderController]', 'Skipping drawing placement initialization', {
+ unitId,
+ subUnitId,
+ drawingId,
+ transform: drawingData.transform,
+ sheetTransform: drawingData.sheetTransform,
+ error,
});
- } else {
- refreshedDrawings.push(refreshSheetDrawingPlacement(drawingData, skeletonParam.skeleton));
}
}
}
diff --git a/packages/sheets-drawing/src/basics/transform-position.ts b/packages/sheets-drawing/src/basics/transform-position.ts
index 3720f99124..343eac2402 100644
--- a/packages/sheets-drawing/src/basics/transform-position.ts
+++ b/packages/sheets-drawing/src/basics/transform-position.ts
@@ -17,8 +17,8 @@
import type { ITransformState, Nullable } from '@univerjs/core';
import type { SpreadsheetSkeleton } from '@univerjs/engine-render';
import type { ISheetSkeletonManagerParam } from '@univerjs/sheets';
-import type { ISheetDrawingPosition } from '../services/sheet-drawing.service';
import { convertPositionSheetOverGridToAbsolute } from '@univerjs/sheets';
+import type { ISheetDrawingPosition } from '../services/sheet-drawing.service';
export function drawingPositionToTransform(position: ISheetDrawingPosition, sheetSkeletonParam: Nullable<ISheetSkeletonManagerParam>): Nullable<ITransformState> {
if (!sheetSkeletonParam) return;
@@ -55,8 +55,8 @@ export function drawingPositionToTransform(position: ISheetDrawingPosition, shee
// use transform and originSize convert to ISheetDrawingPosition
export function transformToDrawingPosition(transform: ITransformState, skeleton: SpreadsheetSkeleton): ISheetDrawingPosition {
const { left = 0, top = 0, width = 0, height = 0, flipY = false, flipX = false, angle = 0, skewX = 0, skewY = 0 } = transform;
- const startSelectionCell = skeleton.getCellIndexAndOffsetByPosition(left, top);
- const endSelectionCell = skeleton.getCellIndexAndOffsetByPosition(left + width, top + height);
+ const startSelectionCell = skeleton.getCellIndexAndOffsetByPosition(left, top, 1, 1, { x: 0, y: 0 });
+ const endSelectionCell = skeleton.getCellIndexAndOffsetByPosition(left + width, top + height, 1, 1, { x: 0, y: 0 });
return {
flipY,
diff --git a/packages/sheets-drawing/src/controllers/__tests__/sheet-drawing-transform-affected.controller.spec.ts b/packages/sheets-drawing/src/controllers/__tests__/sheet-drawing-transform-affected.controller.spec.ts
index 6390e78a1f..2ace66b097 100644
--- a/packages/sheets-drawing/src/controllers/__tests__/sheet-drawing-transform-affected.controller.spec.ts
+++ b/packages/sheets-drawing/src/controllers/__tests__/sheet-drawing-transform-affected.controller.spec.ts
@@ -16,9 +16,11 @@
import type { IWorkbookData, Workbook } from '@univerjs/core';
import {
+ DesktopLogService,
Direction,
DrawingTypeEnum,
ICommandService,
+ ILogService,
ImageSourceType,
Injector,
IResourceLoaderService,
@@ -195,6 +197,7 @@ function createController(options: { drawingData?: Record<string, any>; skeleton
[SheetsSelectionsService, { useValue: {} }],
[IUniverInstanceService, { useValue: {} }],
[SheetDrawingTransformPlanService],
+ [ILogService, { useClass: DesktopLogService }],
[SheetDrawingTransformAffectedController],
]);
injectors.push(injector);
@@ -660,6 +663,180 @@ describe('sheet drawing transforms without UI plugins', () => {
expect(getDrawing(service)).toEqual(after);
});
+ it.each([true, false])('preserves fixed image dimensions after repeated deletion with rows=%s', async (rows) => {
+ const service = await insertDrawing(SheetDrawingAnchorType.Position);
+ const original = getDrawing(service);
+ const legacy = {
+ ...original,
+ sheetTransform: { ...original.sheetTransform, to: { ...original.sheetTransform.to, row: -2, column: -2 } },
+ };
+ expect(testBed.commandService.syncExecuteCommand(InsertSheetDrawingCommand.id, {
+ unitId: 'test',
+ drawings: [{ ...legacy, drawingId: 'legacy-position' }],
+ })).toBe(true);
+ const read = () => Tools.deepClone(service.getDrawingByParam({ ...legacy, drawingId: 'legacy-position' })!);
+ const before = read();
+ const commandId = rows ? RemoveRowCommand.id : RemoveColCommand.id;
+ for (let i = 0; i < 2; i++) {
+ expect(await testBed.commandService.executeCommand(commandId, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ range: { startRow: 0, endRow: rows ? 0 : 19, startColumn: 0, endColumn: rows ? 19 : 0 },
+ })).toBe(true);
+ expect(read().transform).toMatchObject({ width: before.transform?.width, height: before.transform?.height });
+ expect(read().sheetTransform.to.row).toBeGreaterThanOrEqual(0);
+ expect(read().sheetTransform.to.column).toBeGreaterThanOrEqual(0);
+ }
+ const after = read();
+ for (let i = 0; i < 2; i++) {
+ expect(await testBed.commandService.executeCommand(UndoCommandId)).toBe(true);
+ }
+ expect(read()).toEqual(before);
+ for (let i = 0; i < 2; i++) {
+ expect(await testBed.commandService.executeCommand(RedoCommandId)).toBe(true);
+ }
+ expect(read()).toEqual(after);
+ });
+
+ it.each([DeleteRangeMoveLeftCommand.id, DeleteRangeMoveUpCommand.id])('keeps fractional fixed sizes through %s', async (commandId) => {
+ const service = await insertDrawing(SheetDrawingAnchorType.Position);
+ expect(testBed.commandService.syncExecuteCommand(SetSheetDrawingPlacementCommand.id, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ drawings: [{
+ drawingId: 'drawing-1',
+ placement: {
+ kind: SheetDrawingAnchorType.Position,
+ from: { row: 3, column: 3, rowOffset: 2, columnOffset: 2 },
+ width: 180.35,
+ height: 46.25,
+ },
+ }],
+ })).toBe(true);
+ const before = Tools.deepClone(getDrawing(service));
+ const rows = commandId === DeleteRangeMoveUpCommand.id;
+ expect(await testBed.commandService.executeCommand(commandId, {
+ range: { startRow: 0, endRow: rows ? 0 : 19, startColumn: 0, endColumn: rows ? 19 : 0 },
+ })).toBe(true);
+ expect(getDrawing(service).transform).toMatchObject({ width: 180.35, height: 46.25 });
+ expect(await testBed.commandService.executeCommand(UndoCommandId)).toBe(true);
+ expect(getDrawing(service)).toEqual(before);
+ });
+
+ it.each([true, false])('moves a deleted Position anchor to the boundary with unequal cell sizes and rows=%s', async (rows) => {
+ const service = await insertDrawing(SheetDrawingAnchorType.Position);
+ expect(await testBed.commandService.executeCommand(rows ? SetRowHeightCommand.id : SetColWidthCommand.id, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ ranges: [{ startRow: 2, endRow: 2, startColumn: 2, endColumn: 2 }],
+ value: 100,
+ })).toBe(true);
+ expect(testBed.commandService.syncExecuteCommand(SetSheetDrawingPlacementCommand.id, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ drawings: [{
+ drawingId: 'drawing-1',
+ placement: {
+ kind: SheetDrawingAnchorType.Position,
+ from: { row: 3, column: 3, rowOffset: 2, columnOffset: 2 },
+ width: 180.35,
+ height: 46.25,
+ },
+ }],
+ })).toBe(true);
+ const before = Tools.deepClone(getDrawing(service));
+ const skeleton = testBed.get(SheetSkeletonService).ensureSkeleton('test', 'sheet1')!;
+ const boundary = skeleton.getNoMergeCellWithCoordByIndex(1, 1);
+ expect(await testBed.commandService.executeCommand(rows ? RemoveRowCommand.id : RemoveColCommand.id, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ range: { startRow: rows ? 1 : 0, endRow: rows ? 3 : 19, startColumn: rows ? 0 : 1, endColumn: rows ? 19 : 3 },
+ })).toBe(true);
+ expect(getDrawing(service).transform).toMatchObject({
+ [rows ? 'top' : 'left']: rows ? boundary.startY : boundary.startX,
+ width: 180.35,
+ height: 46.25,
+ });
+ expect(await testBed.commandService.executeCommand(UndoCommandId)).toBe(true);
+ expect(getDrawing(service)).toEqual(before);
+ });
+
+ it.each([true, false])('clips a Both endpoint at the sheet boundary when deleting the last rows=%s', async (rows) => {
+ const service = await insertDrawing(SheetDrawingAnchorType.Both);
+ expect(testBed.commandService.syncExecuteCommand(SetSheetDrawingPlacementCommand.id, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ drawings: [{
+ drawingId: 'drawing-1',
+ placement: {
+ kind: SheetDrawingAnchorType.Both,
+ from: { row: 0, column: 0, rowOffset: 0, columnOffset: 0 },
+ to: { row: 18, column: 18, rowOffset: 0, columnOffset: 0 },
+ },
+ }],
+ })).toBe(true);
+ const before = Tools.deepClone(getDrawing(service));
+ const skeleton = testBed.get(SheetSkeletonService).ensureSkeleton('test', 'sheet1')!;
+ const boundary = skeleton.getNoMergeCellWithCoordByIndex(15, 15);
+ expect(await testBed.commandService.executeCommand(rows ? RemoveRowCommand.id : RemoveColCommand.id, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ range: { startRow: rows ? 15 : 0, endRow: 19, startColumn: rows ? 0 : 15, endColumn: 19 },
+ })).toBe(true);
+ const after = getDrawing(service);
+ const position = rows ? 'top' : 'left';
+ const size = rows ? 'height' : 'width';
+ expect((after.transform?.[position] ?? 0) + (after.transform?.[size] ?? 0))
+ .toBe(rows ? boundary.startY : boundary.startX);
+ expect(await testBed.commandService.executeCommand(UndoCommandId)).toBe(true);
+ expect(getDrawing(service)).toEqual(before);
+ });
+
+ it.each([true, false])('keeps both anchors valid when deleting the first rows=%s', async (rows) => {
+ const service = await insertDrawing(SheetDrawingAnchorType.Both);
+ expect(testBed.commandService.syncExecuteCommand(SetSheetDrawingPlacementCommand.id, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ drawings: [{
+ drawingId: 'drawing-1',
+ placement: {
+ kind: SheetDrawingAnchorType.Both,
+ from: { row: 0, column: 0, rowOffset: 0, columnOffset: 0 },
+ to: { row: 4, column: 4, rowOffset: 0, columnOffset: 0 },
+ },
+ }],
+ })).toBe(true);
+ const before = Tools.deepClone(getDrawing(service));
+ expect(await testBed.commandService.executeCommand(rows ? RemoveRowCommand.id : RemoveColCommand.id, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ range: { startRow: 0, endRow: rows ? 2 : 19, startColumn: 0, endColumn: rows ? 19 : 2 },
+ })).toBe(true);
+ const after = Tools.deepClone(getDrawing(service));
+ expect(after.sheetTransform.from).toMatchObject({ row: 0, column: 0 });
+ expect(after.sheetTransform.to[rows ? 'row' : 'column']).toBe(1);
+ expect(after.transform?.[rows ? 'height' : 'width']).toBeGreaterThanOrEqual(0);
+ expect(await testBed.commandService.executeCommand(UndoCommandId)).toBe(true);
+ expect(getDrawing(service)).toEqual(before);
+ expect(await testBed.commandService.executeCommand(RedoCommandId)).toBe(true);
+ expect(getDrawing(service)).toEqual(after);
+ });
+
+ it.each([true, false])('expands both anchors when an inserted block overlaps the endpoint with rows=%s', async (rows) => {
+ const service = await insertDrawing(SheetDrawingAnchorType.Both);
+ const before = Tools.deepClone(getDrawing(service));
+ expect(await testBed.commandService.executeCommand(rows ? InsertRowCommand.id : InsertColCommand.id, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ direction: rows ? Direction.DOWN : Direction.RIGHT,
+ range: { startRow: rows ? 2 : 0, endRow: rows ? 5 : 19, startColumn: rows ? 0 : 2, endColumn: rows ? 19 : 5 },
+ })).toBe(true);
+ const size = rows ? 'height' : 'width';
+ expect(getDrawing(service).transform?.[size]).toBeGreaterThan(before.transform?.[size] ?? 0);
+ expect(await testBed.commandService.executeCommand(UndoCommandId)).toBe(true);
+ expect(getDrawing(service)).toEqual(before);
+ });
+
it.each([
['insert row', InsertRowCommand.id, {
unitId: 'test',
@@ -1199,6 +1376,164 @@ describe('sheet drawing transforms without UI plugins', () => {
}
});
+ it.each([
+ [SheetDrawingAnchorType.Position, false, undefined],
+ [undefined, false, undefined],
+ [SheetDrawingAnchorType.Both, false, undefined],
+ [SheetDrawingAnchorType.Position, true, undefined],
+ [SheetDrawingAnchorType.Position, false, 'from'],
+ [SheetDrawingAnchorType.Position, false, 'to'],
+ [SheetDrawingAnchorType.Both, false, 'from'],
+ [SheetDrawingAnchorType.Both, false, 'to'],
+ [SheetDrawingAnchorType.Both, false, 'sheetTransform'],
+ ] as const)('isolates invalid snapshot placement with anchor=%s, legacy markers=%s and missing=%s during replay', async (anchorType, legacyMarkers, missing) => {
+ const service = await insertDrawing(SheetDrawingAnchorType.Both);
+ const healthy = Tools.deepClone(getDrawing(service));
+ const from = legacyMarkers
+ ? { column: 3, columnOffset: 0, row: 198, rowOffset: -4460 }
+ : { ...healthy.sheetTransform.from, row: anchorType === SheetDrawingAnchorType.Both ? -1 : 1 };
+ const to = legacyMarkers
+ ? { column: 4, columnOffset: 60.3, row: -2, rowOffset: 0 }
+ : healthy.sheetTransform.to;
+ const invalid: ISheetDrawing = {
+ ...healthy,
+ drawingId: 'invalid-image',
+ anchorType,
+ transform: { ...healthy.transform, top: -4243, width: 180.3, height: -4243 },
+ sheetTransform: { from, to },
+ axisAlignSheetTransform: { from, to },
+ };
+ if (missing === 'sheetTransform') {
+ Reflect.deleteProperty(invalid, missing);
+ } else if (missing) {
+ Reflect.deleteProperty(invalid.sheetTransform, missing);
+ }
+ const snapshot = testBed.get(IResourceLoaderService).saveUnit<IWorkbookData>('test')!;
+ snapshot.sheets.sheet1.rowCount = 300;
+ snapshot.resources!.find(({ name }) => name === SHEET_DRAWING_PLUGIN)!.data = JSON.stringify({
+ sheet1: {
+ data: { [invalid.drawingId]: invalid, [healthy.drawingId]: healthy },
+ order: [invalid.drawingId, healthy.drawingId],
+ },
+ });
+ const restored = createSheetsDrawingTestBed(snapshot);
+ const warn = vi.spyOn(DesktopLogService.prototype, 'warn');
+ try {
+ const restoredService = restored.get(ISheetDrawingService);
+ const drawingManager = restored.get(IDrawingManagerService);
+ const worksheet = restored.workbook.getSheetBySheetId('sheet1')!;
+ const originalHeight = worksheet.getRowHeight(2);
+
+ expect(restoredService.getDrawingByParam(invalid)).toEqual(invalid);
+ expect(restored.commandService.syncExecuteCommand(SetWorksheetRowAutoHeightMutation.id, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ rowsAutoHeightInfo: [{ row: 2, autoHeight: originalHeight + 30 }],
+ })).toBe(true);
+ await Promise.resolve();
+
+ const afterAutoHeight = Tools.deepClone(getDrawing(restoredService));
+ expect(afterAutoHeight.transform?.height).toBeCloseTo((healthy.transform?.height ?? 0) + 30);
+ expect(drawingManager.getDrawingByParam(healthy)).toEqual(afterAutoHeight);
+ expect(restoredService.getDrawingByParam(invalid)).toEqual(invalid);
+ expect(drawingManager.getDrawingByParam(invalid)).toEqual(invalid);
+ expect(warn).toHaveBeenCalledWith(expect.any(String), expect.any(String), expect.objectContaining({
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ drawingId: invalid.drawingId,
+ commandId: SetWorksheetRowAutoHeightMutation.id,
+ failure: expect.objectContaining({ ok: false, reason: expect.any(String) }),
+ }));
+
+ const originalWidth = worksheet.getColumnWidth(2);
+ expect(await restored.commandService.executeCommand(SetColWidthCommand.id, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ ranges: [{ startRow: 0, endRow: 299, startColumn: 2, endColumn: 2 }],
+ value: originalWidth + 50,
+ })).toBe(true);
+ const afterColumnWidth = Tools.deepClone(getDrawing(restoredService));
+ expect(afterColumnWidth.transform?.width).toBeCloseTo((afterAutoHeight.transform?.width ?? 0) + 50);
+ expect(await restored.commandService.executeCommand(UndoCommandId)).toBe(true);
+ expect(getDrawing(restoredService)).toEqual(afterAutoHeight);
+ expect(await restored.commandService.executeCommand(RedoCommandId)).toBe(true);
+ expect(getDrawing(restoredService)).toEqual(afterColumnWidth);
+ expect(drawingManager.getDrawingByParam(healthy)).toEqual(afterColumnWidth);
+ expect(restoredService.getDrawingByParam(invalid)).toEqual(invalid);
+ expect(drawingManager.getDrawingByParam(invalid)).toEqual(invalid);
+ } finally {
+ restored.univer.dispose();
+ warn.mockRestore();
+ }
+ });
+
+ it('contains a refresh extension failure and refreshes again after the extension recovers', async () => {
+ const service = await insertDrawing(SheetDrawingAnchorType.Both);
+ const before = Tools.deepClone(getDrawing(service));
+ const error = new Error('Drawing extension failed');
+ const extension = testBed.get(SheetDrawingTransformPlanService).register({
+ transform: () => { throw error; },
+ });
+ const log = vi.spyOn(DesktopLogService.prototype, 'error');
+ try {
+ expect(testBed.commandService.syncExecuteCommand(SetWorksheetRowAutoHeightMutation.id, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ rowsAutoHeightInfo: [{ row: 2, autoHeight: 60 }],
+ })).toBe(true);
+ await Promise.resolve();
+
+ expect(getDrawing(service)).toEqual(before);
+ expect(testBed.get(IDrawingManagerService).getDrawingByParam(before)).toEqual(before);
+ expect(log).toHaveBeenCalledWith(expect.any(String), expect.any(String), expect.objectContaining({
+ commandId: SetWorksheetRowAutoHeightMutation.id,
+ error,
+ }));
+
+ extension.dispose();
+ expect(testBed.commandService.syncExecuteCommand(SetWorksheetRowAutoHeightMutation.id, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ rowsAutoHeightInfo: [{ row: 2, autoHeight: 80 }],
+ })).toBe(true);
+ await Promise.resolve();
+ expect(getDrawing(service).transform?.height).toBeGreaterThan(before.transform?.height ?? 0);
+ } finally {
+ extension.dispose();
+ log.mockRestore();
+ }
+ });
+
+ it.each(['controller', 'unit'] as const)('cancels a queued drawing refresh when the %s is disposed', async (owner) => {
+ const service = await insertDrawing(SheetDrawingAnchorType.Both);
+ const before = Tools.deepClone(getDrawing(service));
+ const plans: string[] = [];
+ const extension = testBed.get(SheetDrawingTransformPlanService).register({
+ transform: (plan) => { plans.push(plan.mode); },
+ });
+ try {
+ expect(testBed.commandService.syncExecuteCommand(SetWorksheetRowAutoHeightMutation.id, {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ rowsAutoHeightInfo: [{ row: 2, autoHeight: 60 }],
+ })).toBe(true);
+ if (owner === 'controller') {
+ testBed.get(SheetDrawingTransformAffectedController).dispose();
+ } else {
+ testBed.get(IUniverInstanceService).disposeUnit('test');
+ }
+ await Promise.resolve();
+ expect(plans).toEqual([]);
+ if (owner === 'controller') {
+ expect(getDrawing(service)).toEqual(before);
+ } else {
+ expect(service.getDrawingByParam(before)).toBeUndefined();
+ }
+ } finally {
+ extension.dispose();
+ }
+ });
+
it('refreshes direct auto-height mutations and their inverse without UI', async () => {
const service = await insertDrawing(SheetDrawingAnchorType.Both);
const before = structuredClone(getDrawing(service));
diff --git a/packages/sheets-drawing/src/controllers/sheet-drawing-transform-affected.controller.ts b/packages/sheets-drawing/src/controllers/sheet-drawing-transform-affected.controller.ts
index f621db7d30..25d88259d5 100644
--- a/packages/sheets-drawing/src/controllers/sheet-drawing-transform-affected.controller.ts
+++ b/packages/sheets-drawing/src/controllers/sheet-drawing-transform-affected.controller.ts
@@ -16,6 +16,7 @@
import type { ICommandInfo, IMutationInfo, IRange, ITransformState, Nullable } from '@univerjs/core';
import type { IDrawingJsonUndo1 } from '@univerjs/drawing';
+import type { SpreadsheetSkeleton } from '@univerjs/engine-render';
import type {
IDeleteRangeMoveLeftCommandParams,
IDeleteRangeMoveUpCommandParams,
@@ -39,10 +40,11 @@ import type {
ISetWorksheetRowIsAutoHeightMutationParams,
ISheetSkeletonManagerParam,
} from '@univerjs/sheets';
-import { Disposable, ICommandService, Inject, IUniverInstanceService, Rectangle } from '@univerjs/core';
+import { Disposable, ICommandService, ILogService, Inject, IUniverInstanceService, Rectangle } from '@univerjs/core';
import { IDrawingManagerService } from '@univerjs/drawing';
import {
attachRangeWithCoord,
+ convertPositionCellToSheetOverGrid,
DeleteRangeMoveLeftCommand,
DeleteRangeMoveUpCommand,
DeltaColumnWidthCommand,
@@ -86,7 +88,7 @@ import {
} from '../basics/transform-position';
import { DrawingApplyType, SetDrawingApplyMutation } from '../commands/mutations/set-drawing-apply.mutation';
import { ClearSheetDrawingTransformerOperation } from '../commands/operations/clear-drawing-transformer.operation';
-import { refreshSheetDrawingPlacement } from '../services/sheet-drawing-placement';
+import { tryRefreshSheetDrawingPlacement, validateSheetDrawingPlacement } from '../services/sheet-drawing-placement';
import { SheetDrawingTransformPlanService } from '../services/sheet-drawing-transform-plan.service';
import { ISheetDrawingService, SheetDrawingAnchorType } from '../services/sheet-drawing.service';
@@ -143,7 +145,8 @@ export class SheetDrawingTransformAffectedController extends Disposable {
@ISheetDrawingService private readonly _sheetDrawingService: ISheetDrawingService,
@IDrawingManagerService private readonly _drawingManagerService: IDrawingManagerService,
@IUniverInstanceService private readonly _univerInstanceService: IUniverInstanceService,
- @Inject(SheetDrawingTransformPlanService) private readonly _transformPlanService: SheetDrawingTransformPlanService
+ @Inject(SheetDrawingTransformPlanService) private readonly _transformPlanService: SheetDrawingTransformPlanService,
+ @ILogService private readonly _logService: ILogService
) {
super();
@@ -430,7 +433,6 @@ export class SheetDrawingTransformAffectedController extends Disposable {
}
if (newSheetTransform && newTransform) {
- const newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
updateDrawings.push({ ...drawing, sheetTransform: newSheetTransform, transform: newTransform, axisAlignSheetTransform });
}
@@ -453,22 +455,13 @@ export class SheetDrawingTransformAffectedController extends Disposable {
Object.keys(drawingData).forEach((drawingId) => {
const drawing = drawingData[drawingId] as ISheetDrawing;
- const { sheetTransform, anchorType = SheetDrawingAnchorType.Position } = drawing;
-
- if (anchorType !== SheetDrawingAnchorType.None) {
- const { row: toRow, column: toColumn } = sheetTransform.to;
-
- for (let i = 0; i < ranges.length; i++) {
- const range = ranges[i];
- const { startRow, startColumn } = range;
-
- if (toRow < startRow || toColumn < startColumn) {
- continue;
- }
-
- updateDrawings.push(refreshSheetDrawingPlacement(drawing, skeleton));
- break;
- }
+ if (drawing?.anchorType === SheetDrawingAnchorType.None) {
+ return;
+ }
+ const refreshed = this._tryRefreshDrawingPlacement(drawing, skeleton, this._currentCommand.id, ({ to }) =>
+ ranges.some(({ startRow, startColumn }) => to.row >= startRow && to.column >= startColumn));
+ if (refreshed) {
+ updateDrawings.push(refreshed);
}
});
@@ -741,7 +734,7 @@ export class SheetDrawingTransformAffectedController extends Disposable {
newTransform = { ...transform, left: (transform.left || 0) + selectionCell.endX - selectionCell.startX };
newSheetTransform = transformToDrawingPosition(newTransform, skeleton);
axisAlignSheetTransform = transformToAxisAlignPosition(newTransform, skeleton) as ISheetDrawingPosition;
- } else if (toColumn >= colEndIndex) {
+ } else if (toColumn >= colStartIndex) {
// move end right only
if (anchorType === SheetDrawingAnchorType.Both) {
newSheetTransform = {
@@ -758,15 +751,7 @@ export class SheetDrawingTransformAffectedController extends Disposable {
}
}
- if (newSheetTransform && newTransform) {
- return {
- newSheetTransform,
- newTransform,
- axisAlignSheetTransform,
- };
- }
-
- return null;
+ return this._getStructuralDrawingResult(newSheetTransform, newTransform, axisAlignSheetTransform, skeleton);
}
private _shrinkCol(
@@ -804,8 +789,11 @@ export class SheetDrawingTransformAffectedController extends Disposable {
from: { ...from, column: fromColumn - colCount },
to: { ...to, column: toColumn - colCount },
};
+ if (anchorType === SheetDrawingAnchorType.Position) {
+ return this._resolveShiftedPositionDrawing(newSheetTransform, transform, sheetSkeletonParam);
+ }
newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
- } else if (fromColumn >= colStartIndex && toColumn <= colEndIndex) {
+ } else if (anchorType === SheetDrawingAnchorType.Both && fromColumn >= colStartIndex && toColumn <= colEndIndex) {
// delete drawing
return null;
} else if (fromColumn < colStartIndex && toColumn > colEndIndex) {
@@ -831,46 +819,28 @@ export class SheetDrawingTransformAffectedController extends Disposable {
};
newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
axisAlignSheetTransform = transformToAxisAlignPosition(newTransform!, skeleton);
- } else if (fromColumn === colStartIndex) {
- newTransform = { ...transform, left: (transform.left || 0) - sheetTransform.from.columnOffset };
} else {
- const selectionCell = attachRangeWithCoord(skeleton, {
- startColumn: colStartIndex,
- endColumn: fromColumn - 1,
- startRow: from.row,
- endRow: to.row,
- });
- newTransform = { ...transform, left: (transform.left || 0) - selectionCell.endX + selectionCell.startX - sheetTransform.from.columnOffset };
- }
-
- if (!newSheetTransform) {
- newSheetTransform = transformToDrawingPosition(newTransform!, skeleton);
- axisAlignSheetTransform = transformToAxisAlignPosition(newTransform!, skeleton);
+ return this._resolveShiftedPositionDrawing({
+ ...sheetTransform,
+ from: { ...from, column: colStartIndex, columnOffset: 0 },
+ }, transform, sheetSkeletonParam);
}
} else if (toColumn >= colStartIndex && toColumn <= colEndIndex && anchorType === SheetDrawingAnchorType.Both) {
- // shrink end col left, then set toColOffset to full cell width
- const selectionCell = attachRangeWithCoord(skeleton, {
- startColumn: colStartIndex - 1,
- endColumn: colStartIndex - 1,
- startRow: from.row,
- endRow: to.row,
- });
+ // At the sheet edge there is no surviving column after the deletion boundary.
+ const boundaryColumn = Math.min(colStartIndex, skeleton.worksheet.getColumnCount() - 1);
+ const boundaryCell = skeleton.getNoMergeCellWithCoordByIndex(from.row, boundaryColumn);
newSheetTransform = {
from: { ...from },
- to: { ...to, column: colStartIndex - 1, columnOffset: selectionCell.endX - selectionCell.startX },
+ to: {
+ ...to,
+ column: boundaryColumn,
+ columnOffset: boundaryColumn < colStartIndex ? boundaryCell.endX - boundaryCell.startX : 0,
+ },
};
newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
}
- if (newSheetTransform && newTransform) {
- return {
- newSheetTransform,
- newTransform,
- axisAlignSheetTransform,
- };
- }
-
- return null;
+ return this._getStructuralDrawingResult(newSheetTransform, newTransform, axisAlignSheetTransform, skeleton);
}
private _expandRow(
@@ -913,7 +883,7 @@ export class SheetDrawingTransformAffectedController extends Disposable {
newTransform = { ...transform, top: (transform.top || 0) + selectionCell.endY - selectionCell.startY };
newSheetTransform = transformToDrawingPosition(newTransform, skeleton);
axisAlignSheetTransform = transformToAxisAlignPosition(newTransform, skeleton) as ISheetDrawingPosition;
- } else if (toRow >= rowEndIndex) {
+ } else if (toRow >= rowStartIndex) {
// move end down only
if (anchorType === SheetDrawingAnchorType.Both) {
newSheetTransform = {
@@ -933,15 +903,7 @@ export class SheetDrawingTransformAffectedController extends Disposable {
}
}
- if (newSheetTransform && newTransform) {
- return {
- newSheetTransform,
- newTransform,
- axisAlignSheetTransform,
- };
- }
-
- return null;
+ return this._getStructuralDrawingResult(newSheetTransform, newTransform, axisAlignSheetTransform, skeleton);
}
private _shrinkRow(
@@ -979,8 +941,11 @@ export class SheetDrawingTransformAffectedController extends Disposable {
from: { ...from, row: fromRow - rowCount },
to: { ...to, row: toRow - rowCount },
};
+ if (anchorType === SheetDrawingAnchorType.Position) {
+ return this._resolveShiftedPositionDrawing(newSheetTransform, transform, sheetSkeletonParam);
+ }
newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
- } else if (fromRow >= rowStartIndex && toRow <= rowEndIndex) {
+ } else if (anchorType === SheetDrawingAnchorType.Both && fromRow >= rowStartIndex && toRow <= rowEndIndex) {
// delete drawing
return null;
} else if (fromRow < rowStartIndex && toRow > rowEndIndex) {
@@ -1006,45 +971,112 @@ export class SheetDrawingTransformAffectedController extends Disposable {
};
newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
axisAlignSheetTransform = transformToAxisAlignPosition(newTransform!, skeleton);
- } else if (fromRow === rowStartIndex) {
- newTransform = { ...transform, top: (transform.top || 0) - sheetTransform.from.rowOffset };
} else {
- const selectionCell = attachRangeWithCoord(skeleton, {
- startRow: rowStartIndex,
- endRow: fromRow - 1,
- startColumn: from.column,
- endColumn: to.column,
- });
- newTransform = { ...transform, top: (transform.top || 0) - selectionCell.endY + selectionCell.startY - sheetTransform.from.rowOffset };
- }
- if (!newSheetTransform) {
- newSheetTransform = transformToDrawingPosition(newTransform!, skeleton);
- axisAlignSheetTransform = transformToAxisAlignPosition(newTransform!, skeleton);
+ return this._resolveShiftedPositionDrawing({
+ ...sheetTransform,
+ from: { ...from, row: rowStartIndex, rowOffset: 0 },
+ }, transform, sheetSkeletonParam);
}
} else if (toRow >= rowStartIndex && toRow <= rowEndIndex && anchorType === SheetDrawingAnchorType.Both) {
- // shrink end row up, then set toRowOffset to full cell height
- const selectionCell = attachRangeWithCoord(skeleton, {
- startColumn: from.column,
- endColumn: from.column,
- startRow: rowStartIndex - 1,
- endRow: rowStartIndex - 1,
- });
+ // At the sheet edge there is no surviving row after the deletion boundary.
+ const boundaryRow = Math.min(rowStartIndex, skeleton.worksheet.getRowCount() - 1);
+ const boundaryCell = skeleton.getNoMergeCellWithCoordByIndex(boundaryRow, from.column);
newSheetTransform = {
from: { ...from },
- to: { ...to, row: rowStartIndex - 1, rowOffset: selectionCell.endY - selectionCell.startY },
+ to: {
+ ...to,
+ row: boundaryRow,
+ rowOffset: boundaryRow < rowStartIndex ? boundaryCell.endY - boundaryCell.startY : 0,
+ },
};
newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
}
- if (newSheetTransform && newTransform) {
- return {
- newSheetTransform,
- newTransform,
- axisAlignSheetTransform,
- };
+ return this._getStructuralDrawingResult(newSheetTransform, newTransform, axisAlignSheetTransform, skeleton);
+ }
+
+ private _resolveShiftedPositionDrawing(
+ sheetTransform: ISheetDrawingPosition,
+ transform: ITransformState,
+ { unitId, sheetId, skeleton }: ISheetSkeletonManagerParam
+ ) {
+ const converted = convertPositionCellToSheetOverGrid(
+ unitId,
+ sheetId,
+ sheetTransform.from,
+ transform.width ?? 0,
+ transform.height ?? 0,
+ skeleton
+ );
+ const newTransform = { ...transform, ...converted.transform };
+ return this._getStructuralDrawingResult(
+ { ...sheetTransform, ...transformToDrawingPosition(newTransform, skeleton) },
+ newTransform,
+ null,
+ skeleton
+ );
+ }
+
+ private _getStructuralDrawingResult(
+ newSheetTransform: Nullable<ISheetDrawingPosition>,
+ newTransform: Nullable<ITransformState>,
+ axisAlignSheetTransform: Nullable<ISheetDrawingPosition>,
+ skeleton: SpreadsheetSkeleton
+ ) {
+ if (!newSheetTransform || !newTransform) {
+ return null;
+ }
+ const { left = 0, top = 0, width = 0, height = 0 } = newTransform;
+ if (![left, top, width, height].every(Number.isFinite) || width < 0 || height < 0) {
+ return null;
+ }
+ if ([newSheetTransform.from, newSheetTransform.to].some(({ row, column, rowOffset, columnOffset }) =>
+ !Number.isInteger(row) || !Number.isInteger(column) || row < 0 || column < 0 ||
+ !Number.isFinite(rowOffset) || !Number.isFinite(columnOffset))) {
+ return null;
}
+ return {
+ newSheetTransform,
+ newTransform,
+ axisAlignSheetTransform: axisAlignSheetTransform ?? transformToAxisAlignPosition(newTransform, skeleton),
+ };
+ }
- return null;
+ private _tryRefreshDrawingPlacement(
+ drawing: ISheetDrawing,
+ skeleton: SpreadsheetSkeleton,
+ commandId: string,
+ shouldRefresh?: (position: ISheetDrawingPosition) => boolean
+ ): ISheetDrawing | undefined {
+ try {
+ const failure = validateSheetDrawingPlacement(drawing);
+ if (failure) {
+ this._logSkippedDrawingRefresh(drawing, commandId, failure);
+ return;
+ }
+ if (shouldRefresh && !shouldRefresh(drawing.sheetTransform)) {
+ return;
+ }
+ const result = tryRefreshSheetDrawingPlacement(drawing, skeleton);
+ if (result.ok) {
+ return result.drawing;
+ }
+ this._logSkippedDrawingRefresh(drawing, commandId, result);
+ } catch (error) {
+ this._logSkippedDrawingRefresh(drawing, commandId, error);
+ }
+ }
+
+ private _logSkippedDrawingRefresh(drawing: ISheetDrawing, commandId: string, failure: unknown): void {
+ this._logService.warn('[SheetDrawingTransformAffectedController]', 'Skipping drawing placement refresh', {
+ unitId: drawing?.unitId,
+ subUnitId: drawing?.subUnitId,
+ drawingId: drawing?.drawingId,
+ commandId,
+ transform: drawing?.transform,
+ sheetTransform: drawing?.sheetTransform,
+ failure,
+ });
}
private _sheetRefreshListener() {
@@ -1055,7 +1087,11 @@ export class SheetDrawingTransformAffectedController extends Disposable {
}
queueMicrotask(() => {
- const params = command.params as
+ if (this._disposed) {
+ return;
+ }
+ try {
+ const params = command.params as
| ISetRowVisibleMutationParams
| ISetRowHiddenMutationParams
| ISetColVisibleMutationParams
@@ -1064,24 +1100,33 @@ export class SheetDrawingTransformAffectedController extends Disposable {
| ISetWorksheetRowAutoHeightMutationParams
| ISetWorksheetRowIsAutoHeightMutationParams
| ISetWorksheetColWidthMutationParams;
- const target = getSheetCommandTarget(this._univerInstanceService, params);
- if (!target) return;
-
- const { unitId, subUnitId, worksheet } = target;
-
- let ranges: IRange[] = [];
- if ('ranges' in params) {
- ranges = params.ranges;
- } else if ('rowsAutoHeightInfo' in params) {
- ranges = params.rowsAutoHeightInfo.map((info) => ({
- startRow: info.row,
- endRow: info.row,
- startColumn: 0,
- endColumn: worksheet.getColumnCount() - 1,
- }));
- }
+ const target = getSheetCommandTarget(this._univerInstanceService, params);
+ if (!target) {
+ return;
+ }
- this._refreshDrawingTransform(command, unitId, subUnitId, ranges);
+ const { unitId, subUnitId, worksheet } = target;
+
+ let ranges: IRange[] = [];
+ if ('ranges' in params) {
+ ranges = params.ranges;
+ } else if ('rowsAutoHeightInfo' in params) {
+ ranges = params.rowsAutoHeightInfo.map((info) => ({
+ startRow: info.row,
+ endRow: info.row,
+ startColumn: 0,
+ endColumn: worksheet.getColumnCount() - 1,
+ }));
+ }
+
+ this._refreshDrawingTransform(command, unitId, subUnitId, ranges);
+ } catch (error) {
+ this._logService.error('[SheetDrawingTransformAffectedController]', 'Drawing layout refresh failed', {
+ commandId: command.id,
+ params: command.params,
+ error,
+ });
+ }
});
})
);
@@ -1098,37 +1143,33 @@ export class SheetDrawingTransformAffectedController extends Disposable {
Object.keys(drawingData).forEach((drawingId) => {
const drawing = drawingData[drawingId] as ISheetDrawing;
- const { sheetTransform, anchorType = SheetDrawingAnchorType.Position } = drawing;
- if (anchorType === SheetDrawingAnchorType.None) {
- return true;
- }
- if (!sheetTransform) {
- return true;
+ if (drawing?.anchorType === SheetDrawingAnchorType.None) {
+ return;
}
- const { from, to } = sheetTransform;
- const { row: fromRow, column: fromColumn } = from;
- const { row: toRow, column: toColumn } = to;
- for (let i = 0; i < ranges.length; i++) {
- const range = ranges[i];
- const { startRow, endRow, startColumn, endColumn } = range;
- if (Rectangle.intersects(
- {
- startRow,
- endRow,
- startColumn,
- endColumn,
- },
- {
- startRow: fromRow,
- endRow: toRow,
- startColumn: fromColumn,
- endColumn: toColumn,
- }
- ) || fromRow > endRow || fromColumn > endColumn) {
- updateDrawings.push(refreshSheetDrawingPlacement(drawing, sheetSkeletonParam.skeleton));
- break;
- }
+ const refreshed = this._tryRefreshDrawingPlacement(drawing, sheetSkeletonParam.skeleton, command.id, ({ from, to }) => {
+ const { row: fromRow, column: fromColumn } = from;
+ const { row: toRow, column: toColumn } = to;
+ return ranges.some((range) => {
+ const { startRow, endRow, startColumn, endColumn } = range;
+ return Rectangle.intersects(
+ {
+ startRow,
+ endRow,
+ startColumn,
+ endColumn,
+ },
+ {
+ startRow: fromRow,
+ endRow: toRow,
+ startColumn: fromColumn,
+ endColumn: toColumn,
+ }
+ ) || fromRow > endRow || fromColumn > endColumn;
+ });
+ });
+ if (refreshed) {
+ updateDrawings.push(refreshed);
}
});
diff --git a/packages/sheets-drawing/src/services/__tests__/sheet-drawing-placement.spec.ts b/packages/sheets-drawing/src/services/__tests__/sheet-drawing-placement.spec.ts
index 88f4496156..f6c9de3c2e 100644
--- a/packages/sheets-drawing/src/services/__tests__/sheet-drawing-placement.spec.ts
+++ b/packages/sheets-drawing/src/services/__tests__/sheet-drawing-placement.spec.ts
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-import { DrawingTypeEnum } from '@univerjs/core';
+import { DrawingTypeEnum, Tools } from '@univerjs/core';
import {
SetColHiddenCommand,
SetRowHiddenCommand,
@@ -30,6 +30,7 @@ import {
applySheetDrawingPlacement,
normalizeSheetDrawingPlacement,
refreshSheetDrawingPlacement,
+ tryRefreshSheetDrawingPlacement,
} from '../sheet-drawing-placement';
import { SheetDrawingAnchorType } from '../sheet-drawing.service';
@@ -40,6 +41,63 @@ describe('sheet drawing placement extents', () => {
});
afterEach(() => bed.univer.dispose());
+ it.each([
+ ['missing markers', { sheetTransform: undefined }],
+ ['null markers', { sheetTransform: null }],
+ ['missing from', { sheetTransform: { to: { row: 2, column: 2, rowOffset: 0, columnOffset: 0 } } }],
+ ['null to', { sheetTransform: { from: { row: 1, column: 1, rowOffset: 0, columnOffset: 0 }, to: null } }],
+ ['invalid cell', { sheetTransform: {
+ from: { row: NaN, column: 1, rowOffset: 0, columnOffset: 0 },
+ to: { row: 2, column: 2, rowOffset: 0, columnOffset: 0 },
+ } }],
+ ['negative extent', { transform: { left: 10, top: 20, width: 20, height: -4243 } }],
+ ['non-finite extent', { transform: { left: 10, top: 20, width: NaN, height: 20 } }],
+ ])('returns a diagnostic for %s without rewriting the drawing', (_name, patch) => {
+ const skeleton = bed.get(SheetSkeletonService).ensureSkeleton('test', 'sheet1')!;
+ const drawing = {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ drawingId: 'invalid-image',
+ drawingType: DrawingTypeEnum.DRAWING_IMAGE,
+ anchorType: SheetDrawingAnchorType.Position,
+ sheetTransform: {
+ from: { row: 1, column: 1, rowOffset: 0, columnOffset: 0 },
+ to: { row: 2, column: 2, rowOffset: 0, columnOffset: 0 },
+ },
+ transform: { left: 10, top: 20, width: 20, height: 20 },
+ ...patch,
+ } as ISheetDrawing;
+ const before = Tools.deepClone(drawing);
+ const result = tryRefreshSheetDrawingPlacement(drawing, skeleton);
+ expect(result).toMatchObject({ ok: false, reason: expect.any(String) });
+ expect(drawing).toEqual(before);
+ // The existing strict API must still reject the same invalid placement.
+ if (!result.ok) {
+ expect(() => refreshSheetDrawingPlacement(drawing, skeleton)).toThrow(result.reason);
+ }
+ });
+
+ it('reports a negative calculated two-cell extent as a result', () => {
+ const skeleton = bed.get(SheetSkeletonService).ensureSkeleton('test', 'sheet1')!;
+ const drawing = {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ drawingId: 'inverted-image',
+ drawingType: DrawingTypeEnum.DRAWING_IMAGE,
+ anchorType: SheetDrawingAnchorType.Both,
+ sheetTransform: {
+ from: { row: 4, column: 4, rowOffset: 0, columnOffset: 0 },
+ to: { row: 1, column: 1, rowOffset: 0, columnOffset: 0 },
+ },
+ } as ISheetDrawing;
+ const before = Tools.deepClone(drawing);
+ expect(tryRefreshSheetDrawingPlacement(drawing, skeleton)).toMatchObject({
+ ok: false,
+ details: { width: expect.any(Number), height: expect.any(Number) },
+ });
+ expect(drawing).toEqual(before);
+ });
+
it.each([
[0, 81.9],
[81.9, 0],
@@ -113,6 +171,36 @@ describe('sheet drawing placement extents', () => {
expect(refreshSheetDrawingPlacement(hidden, skeleton)).toEqual(drawing);
});
+ it.each([
+ [150, 4800, 0.5],
+ [300, 100, 2],
+ ])('keeps model placements stable with scroll=(%s,%s) and scale=%s', (scrollX, scrollY, scale) => {
+ const skeleton = bed.get(SheetSkeletonService).ensureSkeleton('test', 'sheet1')!;
+ const bounds = { left: 300, top: 85, width: 180.3, height: 46 };
+ const marker = { row: 0, column: 0, rowOffset: 0, columnOffset: 0 };
+ const drawing: ISheetDrawing = {
+ unitId: 'test',
+ subUnitId: 'sheet1',
+ drawingId: 'scrolled-image',
+ drawingType: DrawingTypeEnum.DRAWING_IMAGE,
+ transform: { ...bounds, angle: 90 },
+ sheetTransform: { from: marker, to: marker },
+ axisAlignSheetTransform: { from: marker, to: marker },
+ };
+ for (const kind of [SheetDrawingAnchorType.Position, SheetDrawingAnchorType.Both]) {
+ skeleton.setScroll(0, 0);
+ skeleton.setScale(1);
+ const expected = applySheetDrawingPlacement(drawing, { kind, bounds }, skeleton);
+ skeleton.setScroll(scrollX, scrollY);
+ skeleton.setScale(scale);
+ const actual = applySheetDrawingPlacement(drawing, { kind, bounds }, skeleton);
+ expect(actual).toEqual(expected);
+ expect(refreshSheetDrawingPlacement(actual, skeleton)).toEqual(expected);
+ expect(normalizeSheetDrawingPlacement({ kind, bounds }, skeleton))
+ .toEqual(normalizeSheetDrawingPlacement({ kind, bounds }, bed.get(SheetSkeletonService).ensureSkeleton('test', 'sheet2')!));
+ }
+ });
+
it.each([[0, 0], [-1, 20], [20, -1], [NaN, 20], [20, Infinity]])(
'rejects an invalid extent of %s by %s',
(width, height) => {
diff --git a/packages/sheets-drawing/src/services/sheet-drawing-placement.ts b/packages/sheets-drawing/src/services/sheet-drawing-placement.ts
index 699d9e1eb2..7a1a3cc68b 100644
--- a/packages/sheets-drawing/src/services/sheet-drawing-placement.ts
+++ b/packages/sheets-drawing/src/services/sheet-drawing-placement.ts
@@ -96,6 +96,21 @@ export interface ISheetDrawingPlacementByBounds {
*/
export type ISheetDrawingPlacementInput = ISheetDrawingPlacement | ISheetDrawingPlacementByBounds;
+const PLACEMENT_ERROR = {
+ CELL_INVALID: 'SHEET_DRAWING_PLACEMENT_CELL_INVALID',
+ EXTENT_INVALID: 'SHEET_DRAWING_PLACEMENT_EXTENT_INVALID',
+ KIND_INVALID: 'SHEET_DRAWING_PLACEMENT_KIND_INVALID',
+ POSITION_INVALID: 'SHEET_DRAWING_PLACEMENT_POSITION_INVALID',
+} as const;
+
+interface ISheetDrawingPlacementFailure {
+ ok: false;
+ reason: typeof PLACEMENT_ERROR[keyof typeof PLACEMENT_ERROR];
+ details?: Record<string, unknown>;
+}
+
+type SheetDrawingPlacementRefreshResult = { ok: true; drawing: ISheetDrawing } | ISheetDrawingPlacementFailure;
+
export function getSheetDrawingPlacement(drawing: ISheetDrawing): ISheetDrawingPlacement {
const anchorType = drawing.anchorType ?? SheetDrawingAnchorType.Position;
if (anchorType === SheetDrawingAnchorType.None) {
@@ -144,8 +159,7 @@ export function applySheetDrawingPlacement(
input: ISheetDrawingPlacementInput,
skeleton?: SpreadsheetSkeleton
): ISheetDrawing {
- const requiresArea = drawing.drawingType === DrawingTypeEnum.DRAWING_IMAGE
- || drawing.drawingType === DrawingTypeEnum.DRAWING_DOM;
+ const requiresArea = requiresDrawingArea(drawing);
const placement = normalizePlacement(input, skeleton, requiresArea);
return resolveSheetDrawingPlacement(drawing, placement, skeleton);
@@ -153,25 +167,65 @@ export function applySheetDrawingPlacement(
/** Refresh layout-derived geometry without changing the drawing's anchor semantics. */
export function refreshSheetDrawingPlacement(drawing: ISheetDrawing, skeleton: SpreadsheetSkeleton): ISheetDrawing {
+ const result = tryRefreshSheetDrawingPlacement(drawing, skeleton);
+ if (!result.ok) {
+ throw createPlacementError(result);
+ }
+ return result.drawing;
+}
+
+/** Validate persisted markers before any caller reads them to select a refresh range. */
+export function validateSheetDrawingPlacement(drawing: ISheetDrawing): ISheetDrawingPlacementFailure | undefined {
+ if (!drawing || typeof drawing !== 'object') {
+ return { ok: false, reason: PLACEMENT_ERROR.KIND_INVALID };
+ }
+ const anchorType = drawing.anchorType ?? SheetDrawingAnchorType.Position;
+ if (anchorType === SheetDrawingAnchorType.None) {
+ return;
+ }
+ if (anchorType !== SheetDrawingAnchorType.Position && anchorType !== SheetDrawingAnchorType.Both) {
+ return { ok: false, reason: PLACEMENT_ERROR.KIND_INVALID };
+ }
+ const markerFailure = validateCellPosition(drawing.sheetTransform?.from)
+ ?? validateCellPosition(drawing.sheetTransform?.to);
+ if (markerFailure) {
+ return markerFailure;
+ }
+ return validatePlacement(getSheetDrawingPlacement(drawing), requiresDrawingArea(drawing));
+}
+
+/** Expected snapshot errors are results; unexpected calculation failures are caught by the task owner. */
+export function tryRefreshSheetDrawingPlacement(drawing: ISheetDrawing, skeleton: SpreadsheetSkeleton): SheetDrawingPlacementRefreshResult {
+ const failure = validateSheetDrawingPlacement(drawing);
+ if (failure) {
+ return failure;
+ }
if (drawing.anchorType === SheetDrawingAnchorType.None) {
- return drawing;
+ return { ok: true, drawing };
}
const placement = getSheetDrawingPlacement(drawing);
- const requiresArea = drawing.drawingType === DrawingTypeEnum.DRAWING_IMAGE
- || drawing.drawingType === DrawingTypeEnum.DRAWING_DOM;
- // A valid two-cell drawing can temporarily collapse when its cells are hidden.
- validatePlacement(placement, requiresArea);
const resolved = resolveSheetDrawingPlacement(drawing, placement, skeleton);
- validateExtent(resolved.transform?.width ?? 0, resolved.transform?.height ?? 0, requiresArea, true);
+ // A valid two-cell drawing can temporarily collapse when its cells are hidden.
+ const extentFailure = validateExtent(resolved.transform?.width ?? 0, resolved.transform?.height ?? 0, requiresDrawingArea(drawing), true);
+ if (extentFailure) {
+ return extentFailure;
+ }
return {
- ...drawing,
- sheetTransform: resolved.sheetTransform,
- transform: resolved.transform,
- axisAlignSheetTransform: resolved.axisAlignSheetTransform,
+ ok: true,
+ drawing: {
+ ...drawing,
+ sheetTransform: resolved.sheetTransform,
+ transform: resolved.transform,
+ axisAlignSheetTransform: resolved.axisAlignSheetTransform,
+ },
};
}
+function requiresDrawingArea(drawing: ISheetDrawing): boolean {
+ return drawing.drawingType === DrawingTypeEnum.DRAWING_IMAGE || drawing.drawingType === DrawingTypeEnum.DRAWING_DOM;
+}
+
function resolveSheetDrawingPlacement(
drawing: ISheetDrawing,
placement: ISheetDrawingPlacement,
@@ -271,9 +325,9 @@ function normalizePlacement(
requiresArea: boolean
): ISheetDrawingPlacement {
if (!('bounds' in input)) {
- validatePlacement(input, requiresArea);
+ assertValidPlacement(validatePlacement(input, requiresArea));
if (input.kind === SheetDrawingAnchorType.Both && skeleton) {
- validateBounds(convertPositionSheetOverGridToAbsolute(
+ assertValidPlacement(validateBounds(convertPositionSheetOverGridToAbsolute(
skeleton.worksheet.getUnitId(),
skeleton.worksheet.getSheetId(),
{
@@ -281,12 +335,12 @@ function normalizePlacement(
to: input.to,
},
skeleton
- ), requiresArea);
+ ), requiresArea));
}
return input;
}
- validateBounds(input.bounds, requiresArea);
+ assertValidPlacement(validateBounds(input.bounds, requiresArea));
if (input.kind === SheetDrawingAnchorType.None) {
return {
kind: SheetDrawingAnchorType.None,
@@ -314,7 +368,7 @@ function normalizePlacement(
};
}
- throw new Error('SHEET_DRAWING_PLACEMENT_KIND_INVALID');
+ throw new Error(PLACEMENT_ERROR.KIND_INVALID);
}
function withExistingSheetTransform(
@@ -362,39 +416,35 @@ function absoluteSheetTransform(
};
}
-function validatePlacement(placement: ISheetDrawingPlacement, requiresArea: boolean): void {
+function validatePlacement(placement: ISheetDrawingPlacement, requiresArea: boolean): ISheetDrawingPlacementFailure | undefined {
if (placement.kind === SheetDrawingAnchorType.Position) {
- validateCellPosition(placement.from);
- validateExtent(placement.width, placement.height, requiresArea);
- return;
+ return validateCellPosition(placement.from) ?? validateExtent(placement.width, placement.height, requiresArea);
}
if (placement.kind === SheetDrawingAnchorType.Both) {
- validateCellPosition(placement.from);
- validateCellPosition(placement.to);
- return;
+ return validateCellPosition(placement.from) ?? validateCellPosition(placement.to);
}
if (placement.kind === SheetDrawingAnchorType.None) {
if (!Number.isFinite(placement.left) || !Number.isFinite(placement.top)) {
- throw new TypeError('SHEET_DRAWING_PLACEMENT_POSITION_INVALID');
+ return { ok: false, reason: PLACEMENT_ERROR.POSITION_INVALID };
}
- validateExtent(placement.width, placement.height, requiresArea);
- return;
+ return validateExtent(placement.width, placement.height, requiresArea);
}
- throw new Error('SHEET_DRAWING_PLACEMENT_KIND_INVALID');
+ return { ok: false, reason: PLACEMENT_ERROR.KIND_INVALID };
}
-function validateBounds(bounds: IGroupBaseBound, requiresArea: boolean): void {
- if (!Number.isFinite(bounds.left) || !Number.isFinite(bounds.top)) {
- throw new TypeError('SHEET_DRAWING_PLACEMENT_POSITION_INVALID');
+function validateBounds(bounds: IGroupBaseBound, requiresArea: boolean): ISheetDrawingPlacementFailure | undefined {
+ if (!bounds || !Number.isFinite(bounds.left) || !Number.isFinite(bounds.top)) {
+ return { ok: false, reason: PLACEMENT_ERROR.POSITION_INVALID };
}
- validateExtent(bounds.width, bounds.height, requiresArea);
+ return validateExtent(bounds.width, bounds.height, requiresArea);
}
-function validateCellPosition(position: ICellOverGridPosition): void {
+function validateCellPosition(position: ICellOverGridPosition | undefined): ISheetDrawingPlacementFailure | undefined {
if (
+ !position ||
!Number.isInteger(position.row) ||
!Number.isInteger(position.column) ||
position.row < 0 ||
@@ -402,16 +452,26 @@ function validateCellPosition(position: ICellOverGridPosition): void {
!Number.isFinite(position.rowOffset) ||
!Number.isFinite(position.columnOffset)
) {
- throw new Error('SHEET_DRAWING_PLACEMENT_CELL_INVALID');
+ return { ok: false, reason: PLACEMENT_ERROR.CELL_INVALID };
}
}
-function validateExtent(width: number, height: number, requiresArea: boolean, allowCollapsed = false): void {
+function validateExtent(width: number, height: number, requiresArea: boolean, allowCollapsed = false): ISheetDrawingPlacementFailure | undefined {
// Horizontal and vertical lines have a zero bounding-box extent on one axis;
// this is independent of stroke width. Images and floating DOM still require area.
const hasInvalidZeroExtent = !allowCollapsed && (requiresArea ? width === 0 || height === 0 : width === 0 && height === 0);
if (!Number.isFinite(width) || !Number.isFinite(height) || width < 0 || height < 0 || hasInvalidZeroExtent) {
- // Preserve the error message contract and report the actual checked extent, including converted cell bounds.
- throw Object.assign(new Error('SHEET_DRAWING_PLACEMENT_EXTENT_INVALID'), { width, height });
+ return { ok: false, reason: PLACEMENT_ERROR.EXTENT_INVALID, details: { width, height } };
+ }
+}
+
+function assertValidPlacement(failure: ISheetDrawingPlacementFailure | undefined): void {
+ if (failure) {
+ throw createPlacementError(failure);
}
}
+
+function createPlacementError(failure: ISheetDrawingPlacementFailure): Error {
+ const error = failure.reason === PLACEMENT_ERROR.POSITION_INVALID ? new TypeError(failure.reason) : new Error(failure.reason);
+ return Object.assign(error, failure.details);
+}
diff --git a/packages/sheets/src/skeleton/drawing-position-util.ts b/packages/sheets/src/skeleton/drawing-position-util.ts
index bfe4f6c5f3..495eecdd94 100644
--- a/packages/sheets/src/skeleton/drawing-position-util.ts
+++ b/packages/sheets/src/skeleton/drawing-position-util.ts
@@ -15,8 +15,8 @@
*/
import type { SpreadsheetSkeleton } from '@univerjs/engine-render';
-import type { ICellOverGridPosition, ISheetOverGridPosition } from '../basics';
import { precisionTo } from '@univerjs/engine-render';
+import type { ICellOverGridPosition, ISheetOverGridPosition } from '../basics';
import { attachRangeWithCoord } from './util';
export function convertPositionSheetOverGridToAbsolute(
@@ -93,7 +93,7 @@ export function convertPositionCellToSheetOverGrid(
const left = precisionTo(startSelectionX + fromColumnOffset, 1);
const top = precisionTo(startSelectionY + fromRowOffset, 1);
- const endSelectionCell = skeleton.getCellIndexAndOffsetByPosition(left + width, top + height);
+ const endSelectionCell = skeleton.getCellIndexAndOffsetByPosition(left + width, top + height, 1, 1, { x: 0, y: 0 });
return {
unitId,