@univerjs/sheets-drawing 1.0.0-alpha.5 → 1.0.0-alpha.7

package/lib/es/index.js

@@ -1,5 +1,5 @@
-import { CopySheetCommand, RemoveSheetCommand, SheetInterceptorService, convertPositionSheetOverGridToAbsolute } from "@univerjs/sheets";
-import { ArrangeTypeEnum, CommandType, DependentOn, Disposable, DrawingTypeEnum, ICommandService, IConfigService, IResourceManagerService, IUndoRedoService, IUniverInstanceService, Inject, Injector, Plugin, UniverInstanceType, createIdentifier, merge, sequenceExecute } from "@univerjs/core";
+import { CopySheetCommand, DeleteRangeMoveLeftCommand, DeleteRangeMoveUpCommand, DeltaColumnWidthCommand, DeltaRowHeightCommand, InsertColCommand, InsertRangeMoveDownCommand, InsertRangeMoveRightCommand, InsertRowCommand, MoveColsCommand, MoveRangeCommand, MoveRowsCommand, RemoveColCommand, RemoveRowCommand, RemoveSheetCommand, SetColHiddenCommand, SetColHiddenMutation, SetColVisibleMutation, SetColWidthCommand, SetRowHeightCommand, SetRowHiddenCommand, SetRowHiddenMutation, SetRowVisibleMutation, SetSpecificColsVisibleCommand, SetSpecificRowsVisibleCommand, SetWorksheetColWidthMutation, SetWorksheetRowAutoHeightMutation, SetWorksheetRowHeightMutation, SetWorksheetRowIsAutoHeightMutation, SheetInterceptorService, SheetSkeletonService, SheetsSelectionsService, attachRangeWithCoord, convertPositionSheetOverGridToAbsolute, getSheetCommandTarget } from "@univerjs/sheets";
+import { ArrangeTypeEnum, CommandType, DependentOn, Disposable, DrawingTypeEnum, ICommandService, IConfigService, IResourceManagerService, IUndoRedoService, IUniverInstanceService, Inject, Injector, Plugin, RANGE_TYPE, Rectangle, UniverInstanceType, createIdentifier, merge, sequenceExecute, toDisposable } from "@univerjs/core";
 import { IDrawingManagerService, UnitDrawingService, UniverDrawingPlugin, getOrCreateDrawingCopyPlan, resolveDrawingRotateEnabled } from "@univerjs/drawing";
 import { IRenderManagerService } from "@univerjs/engine-render";
 
@@ -652,7 +652,7 @@ SheetsDrawingLoadController = __decorate([
 //#endregion
 //#region package.json
 var name = "@univerjs/sheets-drawing";
-var version = "1.0.0-alpha.5";
+var version = "1.0.0-alpha.7";
 
 //#endregion
 //#region src/config/config.ts
@@ -717,6 +717,1327 @@ function _defineProperty(e, r, t) {
 	}) : e[r] = t, e;
 }
 
+//#endregion
+//#region src/services/sheet-drawing-transform-plan.service.ts
+function createEmptyResult() {
+	return {
+		preRedos: [],
+		redos: [],
+		preUndos: [],
+		undos: []
+	};
+}
+var SheetDrawingTransformPlanService = class {
+	constructor() {
+		_defineProperty(this, "_extensions", []);
+	}
+	register(extension) {
+		this._extensions.push(extension);
+		this._extensions.sort((a, b) => {
+			var _b$priority, _a$priority;
+			return ((_b$priority = b.priority) !== null && _b$priority !== void 0 ? _b$priority : 0) - ((_a$priority = a.priority) !== null && _a$priority !== void 0 ? _a$priority : 0);
+		});
+		return toDisposable(() => {
+			const index = this._extensions.indexOf(extension);
+			if (index >= 0) this._extensions.splice(index, 1);
+		});
+	}
+	transform(plan) {
+		return this._extensions.reduce((all, extension) => {
+			var _next$preRedos, _next$redos, _next$preUndos, _next$undos;
+			const next = extension.transform(plan);
+			if (!next) return all;
+			all.preRedos.push(...(_next$preRedos = next.preRedos) !== null && _next$preRedos !== void 0 ? _next$preRedos : []);
+			all.redos.push(...(_next$redos = next.redos) !== null && _next$redos !== void 0 ? _next$redos : []);
+			all.preUndos.push(...(_next$preUndos = next.preUndos) !== null && _next$preUndos !== void 0 ? _next$preUndos : []);
+			all.undos.push(...(_next$undos = next.undos) !== null && _next$undos !== void 0 ? _next$undos : []);
+			return all;
+		}, createEmptyResult());
+	}
+};
+
+//#endregion
+//#region src/controllers/sheet-drawing-transform-affected.controller.ts
+const UPDATE_COMMANDS = [
+	InsertRowCommand.id,
+	InsertColCommand.id,
+	RemoveRowCommand.id,
+	RemoveColCommand.id,
+	DeleteRangeMoveLeftCommand.id,
+	DeleteRangeMoveUpCommand.id,
+	InsertRangeMoveDownCommand.id,
+	InsertRangeMoveRightCommand.id,
+	DeltaRowHeightCommand.id,
+	SetRowHeightCommand.id,
+	DeltaColumnWidthCommand.id,
+	SetColWidthCommand.id,
+	SetRowHiddenCommand.id,
+	SetSpecificRowsVisibleCommand.id,
+	SetSpecificColsVisibleCommand.id,
+	SetColHiddenCommand.id,
+	MoveColsCommand.id,
+	MoveRowsCommand.id,
+	MoveRangeCommand.id
+];
+const REFRESH_MUTATIONS = [
+	SetRowVisibleMutation.id,
+	SetRowHiddenMutation.id,
+	SetColVisibleMutation.id,
+	SetColHiddenMutation.id,
+	SetWorksheetRowHeightMutation.id,
+	SetWorksheetRowAutoHeightMutation.id,
+	SetWorksheetRowIsAutoHeightMutation.id,
+	SetWorksheetColWidthMutation.id
+];
+let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffectedController extends Disposable {
+	constructor(_commandService, _sheetSkeletonService, _sheetInterceptorService, _selectionManagerService, _sheetDrawingService, _drawingManagerService, _univerInstanceService, _transformPlanService) {
+		super();
+		this._commandService = _commandService;
+		this._sheetSkeletonService = _sheetSkeletonService;
+		this._sheetInterceptorService = _sheetInterceptorService;
+		this._selectionManagerService = _selectionManagerService;
+		this._sheetDrawingService = _sheetDrawingService;
+		this._drawingManagerService = _drawingManagerService;
+		this._univerInstanceService = _univerInstanceService;
+		this._transformPlanService = _transformPlanService;
+		_defineProperty(this, "_currentCommand", {
+			id: "",
+			params: {}
+		});
+		this._sheetInterceptorListener();
+		this._sheetRefreshListener();
+	}
+	_sheetInterceptorListener() {
+		this.disposeWithMe(this._sheetInterceptorService.interceptAfterCommand({ getMutations: (commandInfo) => {
+			const { id, params } = commandInfo;
+			if (!UPDATE_COMMANDS.includes(id) || !params) return {
+				redos: [],
+				undos: []
+			};
+			this._currentCommand = commandInfo;
+			if (id === InsertRowCommand.id) return this._moveRowInterceptor(params, "insert");
+			else if ([
+				MoveColsCommand.id,
+				MoveRowsCommand.id,
+				MoveRangeCommand.id
+			].includes(id)) {
+				let target;
+				if (id === MoveRangeCommand.id) {
+					const _params = params;
+					if (_params.toUnitId && _params.fromUnitId && _params.toUnitId !== _params.fromUnitId || _params.toSubUnitId && _params.fromSubUnitId && _params.toSubUnitId !== _params.fromSubUnitId) return {
+						redos: [],
+						undos: []
+					};
+					target = getSheetCommandTarget(this._univerInstanceService, {
+						unitId: _params.toUnitId,
+						subUnitId: _params.toSubUnitId
+					});
+				} else target = getSheetCommandTarget(this._univerInstanceService, params);
+				if (!target) return {
+					redos: [],
+					undos: []
+				};
+				const { unitId, subUnitId } = target;
+				const { fromRange, toRange } = params;
+				return this._moveRangeInterceptor(unitId, subUnitId, fromRange, toRange);
+			} else if (id === InsertColCommand.id) return this._moveColInterceptor(params, "insert");
+			else if (id === RemoveRowCommand.id) return this._moveRowInterceptor(params, "remove");
+			else if (id === RemoveColCommand.id) return this._moveColInterceptor(params, "remove");
+			else if (id === DeleteRangeMoveLeftCommand.id) {
+				const { range } = params;
+				return this._getRangeMoveUndo(range, 0);
+			} else if (id === DeleteRangeMoveUpCommand.id) {
+				const { range } = params;
+				return this._getRangeMoveUndo(range, 1);
+			} else if (id === InsertRangeMoveDownCommand.id) {
+				const { range } = params;
+				return this._getRangeMoveUndo(range, 2);
+			} else if (id === InsertRangeMoveRightCommand.id) {
+				const { range } = params;
+				return this._getRangeMoveUndo(range, 3);
+			} else if (id === SetRowHiddenCommand.id || id === SetSpecificRowsVisibleCommand.id) {
+				var _this$_selectionManag;
+				const _params = params;
+				const target = getSheetCommandTarget(this._univerInstanceService, _params);
+				if (!target) return {
+					redos: [],
+					undos: []
+				};
+				const { unitId, subUnitId } = target;
+				const ranges = _params.ranges || ((_this$_selectionManag = this._selectionManagerService.getCurrentSelections()) === null || _this$_selectionManag === void 0 ? void 0 : _this$_selectionManag.map((s) => s.range).filter((r) => r.rangeType === RANGE_TYPE.ROW));
+				if (!ranges || ranges.length === 0) return {
+					redos: [],
+					undos: []
+				};
+				return this._getDrawingUndoForRowVisible(unitId, subUnitId, ranges);
+			} else if (id === SetColHiddenCommand.id || id === SetSpecificColsVisibleCommand.id) {
+				var _this$_selectionManag2;
+				const _params = params;
+				const target = getSheetCommandTarget(this._univerInstanceService, _params);
+				if (!target) return {
+					redos: [],
+					undos: []
+				};
+				const { unitId, subUnitId } = target;
+				const ranges = _params.ranges || ((_this$_selectionManag2 = this._selectionManagerService.getCurrentSelections()) === null || _this$_selectionManag2 === void 0 ? void 0 : _this$_selectionManag2.map((s) => s.range).filter((r) => r.rangeType === RANGE_TYPE.COLUMN));
+				if (!ranges || ranges.length === 0) return {
+					redos: [],
+					undos: []
+				};
+				return this._getDrawingUndoForColVisible(unitId, subUnitId, ranges);
+			} else if (id === DeltaRowHeightCommand.id || id === DeltaColumnWidthCommand.id) {
+				const target = getSheetCommandTarget(this._univerInstanceService);
+				if (!target) return {
+					redos: [],
+					undos: []
+				};
+				const { unitId, subUnitId, worksheet } = target;
+				const ranges = [];
+				if (id === DeltaRowHeightCommand.id) ranges.push({
+					startRow: params.anchorRow,
+					endRow: params.anchorRow,
+					startColumn: 0,
+					endColumn: worksheet.getColumnCount() - 1
+				});
+				else ranges.push({
+					startRow: 0,
+					endRow: worksheet.getRowCount() - 1,
+					startColumn: params.anchorCol,
+					endColumn: params.anchorCol
+				});
+				return this._getDrawingUndoForRowAndColSize(unitId, subUnitId, ranges);
+			} else if (id === SetRowHeightCommand.id || id === SetColWidthCommand.id) {
+				var _this$_selectionManag3;
+				const _params = params;
+				const target = getSheetCommandTarget(this._univerInstanceService, _params);
+				if (!target) return {
+					redos: [],
+					undos: []
+				};
+				const { unitId, subUnitId } = target;
+				const ranges = _params.ranges || ((_this$_selectionManag3 = this._selectionManagerService.getCurrentSelections()) === null || _this$_selectionManag3 === void 0 ? void 0 : _this$_selectionManag3.map((s) => s.range));
+				if (!ranges || ranges.length === 0) return {
+					redos: [],
+					undos: []
+				};
+				return this._getDrawingUndoForRowAndColSize(unitId, subUnitId, ranges);
+			}
+			return {
+				redos: [],
+				undos: []
+			};
+		} }));
+	}
+	_finalizePlan(unitId, subUnitId, updates, deletes = [], mode = "command", command = this._currentCommand) {
+		const skeleton = this._sheetSkeletonService.getSkeleton(unitId, subUnitId);
+		if (!skeleton) return {
+			redos: [],
+			undos: []
+		};
+		const data = this._sheetDrawingService.getDrawingData(unitId, subUnitId);
+		const originals = new Map(Object.entries(data));
+		const plan = {
+			command,
+			mode,
+			unitId,
+			subUnitId,
+			skeleton,
+			originals,
+			updates: /* @__PURE__ */ new Map(),
+			deletes: new Set(deletes.map(({ drawingId }) => drawingId).filter((drawingId) => Boolean(drawingId)))
+		};
+		updates.forEach((patch) => {
+			var _patch$sheetTransform, _patch$axisAlignSheet;
+			if (!patch.drawingId) return;
+			const original = originals.get(patch.drawingId);
+			if (!original) return;
+			plan.updates.set(patch.drawingId, {
+				...original,
+				...patch,
+				transform: {
+					...original.transform,
+					...patch.transform
+				},
+				sheetTransform: (_patch$sheetTransform = patch.sheetTransform) !== null && _patch$sheetTransform !== void 0 ? _patch$sheetTransform : original.sheetTransform,
+				axisAlignSheetTransform: (_patch$axisAlignSheet = patch.axisAlignSheetTransform) !== null && _patch$axisAlignSheet !== void 0 ? _patch$axisAlignSheet : original.axisAlignSheetTransform
+			});
+		});
+		const feature = this._transformPlanService.transform(plan);
+		if (mode === "refresh") {
+			const changed = [...plan.updates.values()].filter((drawing) => JSON.stringify(originals.get(drawing.drawingId)) !== JSON.stringify(drawing));
+			if (changed.length) {
+				this._sheetDrawingService.refreshTransform(changed);
+				this._drawingManagerService.refreshTransform(changed);
+				this._commandService.syncExecuteCommand(ClearSheetDrawingTransformerOperation.id, [unitId]);
+			}
+			return {
+				redos: [],
+				undos: []
+			};
+		}
+		return this._createPlanMutations(plan, feature);
+	}
+	_getCalculatedSkeletonParam(unitId, subUnitId) {
+		const skeletonParam = this._sheetSkeletonService.getSkeletonParam(unitId, subUnitId);
+		if (!skeletonParam) return;
+		skeletonParam.skeleton.makeDirty(true);
+		skeletonParam.skeleton.calculate();
+		return skeletonParam;
+	}
+	_createPlanMutations(plan, feature) {
+		const { unitId, subUnitId } = plan;
+		const redos = [...feature.preRedos];
+		const undos = [...feature.preUndos];
+		const updates = [...plan.updates.values()].filter(({ drawingId }) => !plan.deletes.has(drawingId));
+		if (updates.length) {
+			const { undo, redo, objects } = this._sheetDrawingService.getBatchUpdateOp(updates);
+			redos.push({
+				id: SetDrawingApplyMutation.id,
+				params: {
+					unitId,
+					subUnitId,
+					op: redo,
+					objects,
+					type: 2
+				}
+			});
+			undos.push({
+				id: SetDrawingApplyMutation.id,
+				params: {
+					unitId,
+					subUnitId,
+					op: undo,
+					objects,
+					type: 2
+				}
+			});
+		}
+		if (plan.deletes.size) {
+			const drawings = [...plan.deletes].map((drawingId) => ({
+				unitId,
+				subUnitId,
+				drawingId
+			}));
+			const { undo, redo, objects } = this._sheetDrawingService.getBatchRemoveOp(drawings);
+			redos.push({
+				id: SetDrawingApplyMutation.id,
+				params: {
+					unitId,
+					subUnitId,
+					op: redo,
+					objects,
+					type: 1
+				}
+			});
+			undos.push({
+				id: SetDrawingApplyMutation.id,
+				params: {
+					unitId,
+					subUnitId,
+					op: undo,
+					objects,
+					type: 0
+				}
+			});
+		}
+		redos.push(...feature.redos);
+		undos.push(...feature.undos);
+		if (redos.length || undos.length) {
+			redos.push({
+				id: ClearSheetDrawingTransformerOperation.id,
+				params: [unitId]
+			});
+			undos.push({
+				id: ClearSheetDrawingTransformerOperation.id,
+				params: [unitId]
+			});
+		}
+		return {
+			redos,
+			undos
+		};
+	}
+	_getRangeMoveUndo(range, type) {
+		const target = getSheetCommandTarget(this._univerInstanceService);
+		if (!target) return {
+			redos: [],
+			undos: []
+		};
+		const { unitId, subUnitId } = target;
+		if (!this._getCalculatedSkeletonParam(unitId, subUnitId)) return {
+			redos: [],
+			undos: []
+		};
+		const drawingData = this._sheetDrawingService.getDrawingData(unitId, subUnitId);
+		const updateDrawings = [];
+		const deleteDrawings = [];
+		Object.keys(drawingData).forEach((drawingId) => {
+			const drawing = drawingData[drawingId];
+			const { updateDrawings: updateDrawingsPart, deleteDrawings: deleteDrawingsPart } = this._getUpdateOrDeleteDrawings(range, type, drawing);
+			updateDrawings.push(...updateDrawingsPart);
+			deleteDrawings.push(...deleteDrawingsPart);
+		});
+		return this._finalizePlan(unitId, subUnitId, updateDrawings, deleteDrawings);
+	}
+	_getUpdateOrDeleteDrawings(range, type, drawing) {
+		const updateDrawings = [];
+		const deleteDrawings = [];
+		const { sheetTransform, anchorType = "0", transform, unitId, subUnitId, drawingId } = drawing;
+		const sheetSkeletonParam = this._sheetSkeletonService.getSkeletonParam(unitId, subUnitId);
+		if (!sheetTransform || !transform || !sheetSkeletonParam) return {
+			updateDrawings,
+			deleteDrawings
+		};
+		const { from, to } = sheetTransform;
+		const { row: fromRow, column: fromColumn } = from;
+		const { row: toRow, column: toColumn } = to;
+		const { startRow, endRow, startColumn, endColumn } = range;
+		let newSheetTransform = null;
+		let newTransform = null;
+		let axisAlignSheetTransform;
+		if (type === 0 && fromRow >= startRow && toRow <= endRow) if (fromColumn >= startColumn && toColumn <= endColumn) deleteDrawings.push({
+			unitId,
+			subUnitId,
+			drawingId
+		});
+		else {
+			var _param$axisAlignSheet;
+			const param = this._shrinkCol(startColumn, endColumn, {
+				sheetSkeletonParam,
+				sheetTransform,
+				transform,
+				anchorType
+			});
+			newSheetTransform = param === null || param === void 0 ? void 0 : param.newSheetTransform;
+			newTransform = param === null || param === void 0 ? void 0 : param.newTransform;
+			axisAlignSheetTransform = (_param$axisAlignSheet = param === null || param === void 0 ? void 0 : param.axisAlignSheetTransform) !== null && _param$axisAlignSheet !== void 0 ? _param$axisAlignSheet : void 0;
+		}
+		else if (type === 1 && fromColumn >= startColumn && toColumn <= endColumn) if (fromRow >= startRow && toRow <= endRow) deleteDrawings.push({
+			unitId,
+			subUnitId,
+			drawingId
+		});
+		else {
+			var _param$axisAlignSheet2;
+			const param = this._shrinkRow(startRow, endRow, {
+				sheetSkeletonParam,
+				sheetTransform,
+				transform,
+				anchorType
+			});
+			newSheetTransform = param === null || param === void 0 ? void 0 : param.newSheetTransform;
+			newTransform = param === null || param === void 0 ? void 0 : param.newTransform;
+			axisAlignSheetTransform = (_param$axisAlignSheet2 = param === null || param === void 0 ? void 0 : param.axisAlignSheetTransform) !== null && _param$axisAlignSheet2 !== void 0 ? _param$axisAlignSheet2 : void 0;
+		}
+		else if (type === 2) {
+			var _param$axisAlignSheet3;
+			const param = this._expandRow(startRow, endRow, {
+				sheetSkeletonParam,
+				sheetTransform,
+				transform,
+				anchorType
+			});
+			newSheetTransform = param === null || param === void 0 ? void 0 : param.newSheetTransform;
+			newTransform = param === null || param === void 0 ? void 0 : param.newTransform;
+			axisAlignSheetTransform = (_param$axisAlignSheet3 = param === null || param === void 0 ? void 0 : param.axisAlignSheetTransform) !== null && _param$axisAlignSheet3 !== void 0 ? _param$axisAlignSheet3 : void 0;
+		} else if (type === 3) {
+			var _param$axisAlignSheet4;
+			const param = this._expandCol(startColumn, endColumn, {
+				sheetSkeletonParam,
+				sheetTransform,
+				transform,
+				anchorType
+			});
+			newSheetTransform = param === null || param === void 0 ? void 0 : param.newSheetTransform;
+			newTransform = param === null || param === void 0 ? void 0 : param.newTransform;
+			axisAlignSheetTransform = (_param$axisAlignSheet4 = param === null || param === void 0 ? void 0 : param.axisAlignSheetTransform) !== null && _param$axisAlignSheet4 !== void 0 ? _param$axisAlignSheet4 : void 0;
+		}
+		if (newSheetTransform && newTransform) {
+			const newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
+			updateDrawings.push({
+				...drawing,
+				sheetTransform: newSheetTransform,
+				transform: newTransform,
+				axisAlignSheetTransform
+			});
+		}
+		return {
+			updateDrawings,
+			deleteDrawings
+		};
+	}
+	_remainDrawingSize(transform, updateDrawings, drawing, skeleton) {
+		const newSheetTransform = transformToDrawingPosition({ ...transform }, skeleton);
+		if (newSheetTransform) {
+			const axisAlignSheetTransform = transformToAxisAlignPosition({ ...transform }, skeleton);
+			updateDrawings.push({
+				...drawing,
+				sheetTransform: newSheetTransform,
+				axisAlignSheetTransform
+			});
+		}
+	}
+	_getDrawingUndoForColVisible(unitId, subUnitId, ranges) {
+		const sheetSkeletonParam = this._getCalculatedSkeletonParam(unitId, subUnitId);
+		if (!sheetSkeletonParam) return {
+			redos: [],
+			undos: []
+		};
+		const { skeleton } = sheetSkeletonParam;
+		const drawingData = this._drawingManagerService.getDrawingData(unitId, subUnitId);
+		const updateDrawings = [];
+		const preUpdateDrawings = [];
+		Object.keys(drawingData).forEach((drawingId) => {
+			const drawing = drawingData[drawingId];
+			const { sheetTransform, transform, anchorType = "0" } = drawing;
+			if (anchorType === "2") this._remainDrawingSize(transform, updateDrawings, drawing, skeleton);
+			else {
+				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 { startColumn, endColumn } = ranges[i];
+					if (toColumn < startColumn) continue;
+					if (anchorType === "0") {
+						let newSheetTransform = null;
+						let newTransform = null;
+						if (fromColumn >= startColumn && fromColumn <= endColumn) {
+							const selectionCell = attachRangeWithCoord(skeleton, {
+								startColumn: fromColumn,
+								endColumn,
+								startRow: fromRow,
+								endRow: toRow
+							});
+							newTransform = {
+								...transform,
+								left: selectionCell.startX
+							};
+						}
+						if (newTransform) {
+							newSheetTransform = transformToDrawingPosition(newTransform, skeleton);
+							const axisAlignSheetTransform = transformToAxisAlignPosition(newTransform, skeleton);
+							if (newSheetTransform && newTransform) {
+								updateDrawings.push({
+									...drawing,
+									sheetTransform: newSheetTransform,
+									transform: newTransform,
+									axisAlignSheetTransform
+								});
+								break;
+							}
+						}
+						continue;
+					}
+					if (fromColumn >= startColumn && toColumn <= endColumn) continue;
+					let newSheetTransform = null;
+					let newTransform = null;
+					if (fromColumn >= startColumn && fromColumn <= endColumn) {
+						const selectionCell = attachRangeWithCoord(skeleton, {
+							startColumn: fromColumn,
+							endColumn,
+							startRow: fromRow,
+							endRow: toRow
+						});
+						newTransform = {
+							...transform,
+							left: (selectionCell === null || selectionCell === void 0 ? void 0 : selectionCell.startX) || 0,
+							width: ((transform === null || transform === void 0 ? void 0 : transform.width) || 0) - selectionCell.endX + selectionCell.startX
+						};
+					} else if (toColumn >= startColumn && toColumn <= endColumn) {
+						const selectionCell = attachRangeWithCoord(skeleton, {
+							startColumn,
+							endColumn: toColumn,
+							startRow: fromRow,
+							endRow: toRow
+						});
+						newTransform = {
+							...transform,
+							left: selectionCell.startX - ((transform === null || transform === void 0 ? void 0 : transform.width) || 0)
+						};
+					} else {
+						const selectionCell = attachRangeWithCoord(skeleton, {
+							startColumn,
+							endColumn,
+							startRow: fromRow,
+							endRow: toRow
+						});
+						newTransform = {
+							...transform,
+							width: ((transform === null || transform === void 0 ? void 0 : transform.width) || 0) - selectionCell.endX + selectionCell.startX
+						};
+						newSheetTransform = transformToDrawingPosition(newTransform, skeleton);
+						if (newSheetTransform && newTransform) {
+							const axisAlignSheetTransform = transformToAxisAlignPosition(newTransform, skeleton);
+							preUpdateDrawings.push({
+								...drawing,
+								sheetTransform: newSheetTransform,
+								transform: newTransform,
+								axisAlignSheetTransform
+							});
+							break;
+						}
+					}
+					if (newTransform) newSheetTransform = transformToDrawingPosition(newTransform, skeleton);
+					if (newTransform && newSheetTransform) {
+						const axisAlignSheetTransform = transformToAxisAlignPosition(newTransform, skeleton);
+						updateDrawings.push({
+							...drawing,
+							sheetTransform: newSheetTransform,
+							transform: newTransform,
+							axisAlignSheetTransform
+						});
+						break;
+					} else this._remainDrawingSize(transform, updateDrawings, drawing, skeleton);
+				}
+			}
+		});
+		return this._finalizePlan(unitId, subUnitId, [...preUpdateDrawings, ...updateDrawings]);
+	}
+	_createUndoAndRedoMutation(unitId, subUnitId, updateDrawings) {
+		return this._finalizePlan(unitId, subUnitId, updateDrawings);
+	}
+	_getDrawingUndoForRowVisible(unitId, subUnitId, ranges) {
+		const sheetSkeletonParam = this._getCalculatedSkeletonParam(unitId, subUnitId);
+		if (!sheetSkeletonParam) return {
+			redos: [],
+			undos: []
+		};
+		const { skeleton } = sheetSkeletonParam;
+		const drawingData = this._drawingManagerService.getDrawingData(unitId, subUnitId);
+		const updateDrawings = [];
+		const preUpdateDrawings = [];
+		Object.keys(drawingData).forEach((drawingId) => {
+			const drawing = drawingData[drawingId];
+			const { sheetTransform, transform, anchorType = "0" } = drawing;
+			if (anchorType === "2") this._remainDrawingSize(transform, updateDrawings, drawing, skeleton);
+			else {
+				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 { startRow, endRow } = ranges[i];
+					if (toRow < startRow) continue;
+					if (anchorType === "0") {
+						let newSheetTransform = null;
+						let newTransform = null;
+						if (fromRow >= startRow && fromRow <= endRow) {
+							const selectionCell = attachRangeWithCoord(skeleton, {
+								startColumn: fromColumn,
+								endColumn: toColumn,
+								startRow: fromRow,
+								endRow
+							});
+							newTransform = {
+								...transform,
+								top: selectionCell.startY
+							};
+						}
+						if (newTransform) {
+							newSheetTransform = transformToDrawingPosition(newTransform, skeleton);
+							const axisAlignSheetTransform = transformToAxisAlignPosition(newTransform, skeleton);
+							if (newSheetTransform && newTransform) {
+								updateDrawings.push({
+									...drawing,
+									sheetTransform: newSheetTransform,
+									transform: newTransform,
+									axisAlignSheetTransform
+								});
+								break;
+							}
+						}
+						continue;
+					}
+					if (fromRow >= startRow && toRow <= endRow) continue;
+					let newSheetTransform = null;
+					let newTransform = null;
+					if (fromRow >= startRow && fromRow <= endRow) {
+						const selectionCell = attachRangeWithCoord(skeleton, {
+							startColumn: fromColumn,
+							endColumn: toColumn,
+							startRow: fromRow,
+							endRow
+						});
+						newTransform = {
+							...transform,
+							top: (selectionCell === null || selectionCell === void 0 ? void 0 : selectionCell.startY) || 0,
+							height: ((transform === null || transform === void 0 ? void 0 : transform.height) || 0) - selectionCell.endY + selectionCell.startY
+						};
+					} else if (toRow >= startRow && toRow <= endRow) {
+						const selectionCell = attachRangeWithCoord(skeleton, {
+							startColumn: fromColumn,
+							endColumn: toColumn,
+							startRow,
+							endRow: toRow
+						});
+						newTransform = {
+							...transform,
+							top: selectionCell.startY - ((transform === null || transform === void 0 ? void 0 : transform.height) || 0)
+						};
+					} else {
+						const selectionCell = attachRangeWithCoord(skeleton, {
+							startColumn: fromColumn,
+							endColumn: toColumn,
+							startRow,
+							endRow
+						});
+						newTransform = {
+							...transform,
+							height: ((transform === null || transform === void 0 ? void 0 : transform.height) || 0) - selectionCell.endY + selectionCell.startY
+						};
+						newSheetTransform = transformToDrawingPosition(newTransform, skeleton);
+						if (newSheetTransform && newTransform) {
+							const axisAlignSheetTransform = transformToAxisAlignPosition(newTransform, skeleton);
+							preUpdateDrawings.push({
+								...drawing,
+								sheetTransform: newSheetTransform,
+								transform: newTransform,
+								axisAlignSheetTransform
+							});
+							break;
+						}
+					}
+					if (newTransform) newSheetTransform = transformToDrawingPosition(newTransform, skeleton);
+					if (newTransform && newSheetTransform) {
+						const axisAlignSheetTransform = transformToAxisAlignPosition(newTransform, skeleton);
+						updateDrawings.push({
+							...drawing,
+							sheetTransform: newSheetTransform,
+							transform: newTransform,
+							axisAlignSheetTransform
+						});
+						break;
+					} else this._remainDrawingSize(transform, updateDrawings, drawing, skeleton);
+				}
+			}
+		});
+		return this._finalizePlan(unitId, subUnitId, [...preUpdateDrawings, ...updateDrawings]);
+	}
+	_getDrawingUndoForRowAndColSize(unitId, subUnitId, ranges) {
+		const sheetSkeletonParam = this._getCalculatedSkeletonParam(unitId, subUnitId);
+		if (!sheetSkeletonParam) return {
+			redos: [],
+			undos: []
+		};
+		const { skeleton } = sheetSkeletonParam;
+		const drawingData = this._drawingManagerService.getDrawingData(unitId, subUnitId);
+		const updateDrawings = [];
+		Object.keys(drawingData).forEach((drawingId) => {
+			const drawing = drawingData[drawingId];
+			const { sheetTransform, transform, anchorType = "0" } = drawing;
+			if (anchorType === "2") this._remainDrawingSize(transform, updateDrawings, drawing, skeleton);
+			else {
+				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 { startRow, endRow, startColumn, endColumn } = ranges[i];
+					if (toRow < startRow || toColumn < startColumn) continue;
+					if (anchorType === "0") {
+						if (fromRow <= startRow && toRow >= endRow || fromColumn <= startColumn && toColumn >= endColumn) {
+							this._remainDrawingSize(transform, updateDrawings, drawing, skeleton);
+							continue;
+						}
+					}
+					const newTransform = drawingPositionToTransform({ ...sheetTransform }, sheetSkeletonParam);
+					if (newTransform) {
+						updateDrawings.push({
+							...drawing,
+							transform: newTransform
+						});
+						break;
+					}
+				}
+			}
+		});
+		if (updateDrawings.length === 0) return {
+			redos: [],
+			undos: []
+		};
+		return this._createUndoAndRedoMutation(unitId, subUnitId, updateDrawings);
+	}
+	_getUnitIdAndSubUnitId(params, type) {
+		let target;
+		if (type === "insert") target = getSheetCommandTarget(this._univerInstanceService, params);
+		else target = getSheetCommandTarget(this._univerInstanceService);
+		if (!target) return;
+		const { unitId, subUnitId } = target;
+		return {
+			unitId,
+			subUnitId
+		};
+	}
+	_moveRangeInterceptor(unitId, subUnitId, fromRange, toRange) {
+		const sheetSkeletonParam = this._getCalculatedSkeletonParam(unitId, subUnitId);
+		if (!sheetSkeletonParam) return {
+			redos: [],
+			undos: []
+		};
+		const { skeleton } = sheetSkeletonParam;
+		const selectionRect = attachRangeWithCoord(skeleton, fromRange);
+		if (!selectionRect) return {
+			redos: [],
+			undos: []
+		};
+		const { startX, endX, startY, endY } = selectionRect;
+		const drawings = this._sheetDrawingService.getDrawingData(unitId, subUnitId);
+		const containedDrawings = [];
+		Object.keys(drawings).forEach((drawingId) => {
+			const drawing = drawings[drawingId];
+			if (drawing.anchorType !== "1") return;
+			const { transform } = drawing;
+			if (!transform) return;
+			const { left = 0, top = 0, width = 0, height = 0 } = transform;
+			const { drawingStartX, drawingEndX, drawingStartY, drawingEndY } = {
+				drawingStartX: left,
+				drawingEndX: left + width,
+				drawingStartY: top,
+				drawingEndY: top + height
+			};
+			if (startX <= drawingStartX && drawingEndX <= endX && startY <= drawingStartY && drawingEndY <= endY) containedDrawings.push(drawing);
+		});
+		const rowOffset = toRange.startRow - fromRange.startRow;
+		const colOffset = toRange.startColumn - fromRange.startColumn;
+		const updateDrawings = containedDrawings.map((drawing) => {
+			const oldSheetTransform = drawing.sheetTransform;
+			const sheetTransform = {
+				to: {
+					...oldSheetTransform.to,
+					row: oldSheetTransform.to.row + rowOffset,
+					column: oldSheetTransform.to.column + colOffset
+				},
+				from: {
+					...oldSheetTransform.from,
+					row: oldSheetTransform.from.row + rowOffset,
+					column: oldSheetTransform.from.column + colOffset
+				}
+			};
+			const transform = drawingPositionToTransform(sheetTransform, sheetSkeletonParam);
+			return {
+				unitId,
+				subUnitId,
+				drawingId: drawing.drawingId,
+				transform,
+				sheetTransform
+			};
+		});
+		return this._finalizePlan(unitId, subUnitId, updateDrawings);
+	}
+	_moveRowInterceptor(params, type) {
+		const target = this._getUnitIdAndSubUnitId(params, type);
+		if (!target) return {
+			redos: [],
+			undos: []
+		};
+		const { unitId, subUnitId } = target;
+		const sheetSkeletonParam = this._getCalculatedSkeletonParam(unitId, subUnitId);
+		if (!sheetSkeletonParam) return {
+			redos: [],
+			undos: []
+		};
+		const { range } = params;
+		const rowStartIndex = range.startRow;
+		const rowEndIndex = range.endRow;
+		const data = this._sheetDrawingService.getDrawingData(unitId, subUnitId);
+		const updateDrawings = [];
+		const deleteDrawings = [];
+		Object.keys(data).forEach((drawingId) => {
+			const { sheetTransform, transform, anchorType = "0" } = data[drawingId];
+			if (!sheetTransform || !transform) return;
+			let newSheetTransform;
+			let newTransform;
+			let axisAlignSheetTransform;
+			if (type === "insert") {
+				var _param$axisAlignSheet5;
+				const param = this._expandRow(rowStartIndex, rowEndIndex, {
+					sheetSkeletonParam,
+					sheetTransform,
+					transform,
+					anchorType
+				});
+				newSheetTransform = param === null || param === void 0 ? void 0 : param.newSheetTransform;
+				newTransform = param === null || param === void 0 ? void 0 : param.newTransform;
+				axisAlignSheetTransform = (_param$axisAlignSheet5 = param === null || param === void 0 ? void 0 : param.axisAlignSheetTransform) !== null && _param$axisAlignSheet5 !== void 0 ? _param$axisAlignSheet5 : void 0;
+			} else {
+				const { from, to } = sheetTransform;
+				const { row: fromRow } = from;
+				const { row: toRow } = to;
+				if (anchorType === "1" && fromRow >= rowStartIndex && toRow <= rowEndIndex) deleteDrawings.push({
+					unitId,
+					subUnitId,
+					drawingId
+				});
+				else {
+					var _param$axisAlignSheet6;
+					const param = this._shrinkRow(rowStartIndex, rowEndIndex, {
+						sheetSkeletonParam,
+						sheetTransform,
+						transform,
+						anchorType
+					});
+					newSheetTransform = param === null || param === void 0 ? void 0 : param.newSheetTransform;
+					newTransform = param === null || param === void 0 ? void 0 : param.newTransform;
+					axisAlignSheetTransform = (_param$axisAlignSheet6 = param === null || param === void 0 ? void 0 : param.axisAlignSheetTransform) !== null && _param$axisAlignSheet6 !== void 0 ? _param$axisAlignSheet6 : void 0;
+				}
+			}
+			if (!newSheetTransform || !newTransform) return;
+			const params = {
+				unitId,
+				subUnitId,
+				drawingId,
+				transform: newTransform,
+				sheetTransform: newSheetTransform,
+				axisAlignSheetTransform
+			};
+			updateDrawings.push(params);
+		});
+		return this._finalizePlan(unitId, subUnitId, updateDrawings, deleteDrawings);
+	}
+	_moveColInterceptor(params, type) {
+		const target = this._getUnitIdAndSubUnitId(params, type);
+		if (!target) return {
+			redos: [],
+			undos: []
+		};
+		const { unitId, subUnitId } = target;
+		const sheetSkeletonParam = this._getCalculatedSkeletonParam(unitId, subUnitId);
+		if (!sheetSkeletonParam) return {
+			redos: [],
+			undos: []
+		};
+		const { range } = params;
+		const colStartIndex = range.startColumn;
+		const colEndIndex = range.endColumn;
+		const data = this._sheetDrawingService.getDrawingData(unitId, subUnitId);
+		const updateDrawings = [];
+		const deleteDrawings = [];
+		Object.keys(data).forEach((drawingId) => {
+			const { sheetTransform, transform, anchorType = "0" } = data[drawingId];
+			if (!sheetTransform || !transform) return;
+			let newSheetTransform;
+			let newTransform;
+			let axisAlignSheetTransform;
+			if (type === "insert") {
+				var _param$axisAlignSheet7;
+				const param = this._expandCol(colStartIndex, colEndIndex, {
+					sheetSkeletonParam,
+					sheetTransform,
+					transform,
+					anchorType
+				});
+				newSheetTransform = param === null || param === void 0 ? void 0 : param.newSheetTransform;
+				newTransform = param === null || param === void 0 ? void 0 : param.newTransform;
+				axisAlignSheetTransform = (_param$axisAlignSheet7 = param === null || param === void 0 ? void 0 : param.axisAlignSheetTransform) !== null && _param$axisAlignSheet7 !== void 0 ? _param$axisAlignSheet7 : void 0;
+			} else {
+				const { from, to } = sheetTransform;
+				const { column: fromColumn } = from;
+				const { column: toColumn } = to;
+				if (anchorType === "1" && fromColumn >= colStartIndex && toColumn <= colEndIndex) deleteDrawings.push({
+					unitId,
+					subUnitId,
+					drawingId
+				});
+				else {
+					var _param$axisAlignSheet8;
+					const param = this._shrinkCol(colStartIndex, colEndIndex, {
+						sheetSkeletonParam,
+						sheetTransform,
+						transform,
+						anchorType
+					});
+					newSheetTransform = param === null || param === void 0 ? void 0 : param.newSheetTransform;
+					newTransform = param === null || param === void 0 ? void 0 : param.newTransform;
+					axisAlignSheetTransform = (_param$axisAlignSheet8 = param === null || param === void 0 ? void 0 : param.axisAlignSheetTransform) !== null && _param$axisAlignSheet8 !== void 0 ? _param$axisAlignSheet8 : void 0;
+				}
+			}
+			if (!newSheetTransform || !newTransform) return;
+			const params = {
+				unitId,
+				subUnitId,
+				drawingId,
+				transform: newTransform,
+				sheetTransform: newSheetTransform,
+				axisAlignSheetTransform
+			};
+			updateDrawings.push(params);
+		});
+		return this._finalizePlan(unitId, subUnitId, updateDrawings, deleteDrawings);
+	}
+	_expandCol(colStartIndex, colEndIndex, options) {
+		const { sheetSkeletonParam, sheetTransform, transform, anchorType = "0" } = options;
+		const { skeleton } = sheetSkeletonParam;
+		const colCount = colEndIndex - colStartIndex + 1;
+		const { from, to } = sheetTransform;
+		const { column: fromColumn } = from;
+		const { column: toColumn } = to;
+		if (anchorType === "2") return {
+			newSheetTransform: transformToDrawingPosition({ ...transform }, skeleton),
+			newTransform: transform,
+			axisAlignSheetTransform: transformToAxisAlignPosition({ ...transform }, skeleton)
+		};
+		let newSheetTransform = null;
+		let newTransform = null;
+		let axisAlignSheetTransform = null;
+		if (fromColumn >= colStartIndex) {
+			const selectionCell = attachRangeWithCoord(skeleton, {
+				startColumn: colStartIndex,
+				endColumn: colEndIndex,
+				startRow: from.row,
+				endRow: to.row
+			});
+			newTransform = {
+				...transform,
+				left: (transform.left || 0) + selectionCell.endX - selectionCell.startX
+			};
+			newSheetTransform = transformToDrawingPosition(newTransform, skeleton);
+			axisAlignSheetTransform = transformToAxisAlignPosition(newTransform, skeleton);
+		} else if (toColumn >= colEndIndex) if (anchorType === "1") {
+			newSheetTransform = {
+				from: { ...from },
+				to: {
+					...to,
+					column: toColumn + colCount
+				}
+			};
+			newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
+		} else return {
+			newSheetTransform: transformToDrawingPosition({ ...transform }, skeleton),
+			newTransform: transform,
+			axisAlignSheetTransform: transformToAxisAlignPosition({ ...transform }, skeleton)
+		};
+		if (newSheetTransform && newTransform) return {
+			newSheetTransform,
+			newTransform,
+			axisAlignSheetTransform
+		};
+		return null;
+	}
+	_shrinkCol(colStartIndex, colEndIndex, options) {
+		const { sheetSkeletonParam, sheetTransform, transform, anchorType = "0" } = options;
+		const { skeleton } = sheetSkeletonParam;
+		const colCount = colEndIndex - colStartIndex + 1;
+		const { from, to } = sheetTransform;
+		const { column: fromColumn } = from;
+		const { column: toColumn } = to;
+		if (anchorType === "2") return {
+			newSheetTransform: transformToDrawingPosition({ ...transform }, skeleton),
+			newTransform: transform,
+			axisAlignSheetTransform: transformToAxisAlignPosition({ ...transform }, skeleton)
+		};
+		let newSheetTransform = null;
+		let newTransform = null;
+		let axisAlignSheetTransform = null;
+		if (fromColumn > colEndIndex) {
+			newSheetTransform = {
+				from: {
+					...from,
+					column: fromColumn - colCount
+				},
+				to: {
+					...to,
+					column: toColumn - colCount
+				}
+			};
+			newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
+		} else if (fromColumn >= colStartIndex && toColumn <= colEndIndex) return null;
+		else if (fromColumn < colStartIndex && toColumn > colEndIndex) if (anchorType === "1") {
+			newSheetTransform = {
+				from: { ...from },
+				to: {
+					...to,
+					column: toColumn - colCount
+				}
+			};
+			newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
+		} else return {
+			newSheetTransform: transformToDrawingPosition({ ...transform }, skeleton),
+			newTransform: transform,
+			axisAlignSheetTransform: transformToAxisAlignPosition({ ...transform }, skeleton)
+		};
+		else if (fromColumn >= colStartIndex && fromColumn <= colEndIndex) {
+			if (anchorType === "1") {
+				newSheetTransform = {
+					from: {
+						...from,
+						column: colStartIndex,
+						columnOffset: 0
+					},
+					to: {
+						...to,
+						column: toColumn - colCount
+					}
+				};
+				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);
+			}
+		} else if (toColumn >= colStartIndex && toColumn <= colEndIndex && anchorType === "1") {
+			const selectionCell = attachRangeWithCoord(skeleton, {
+				startColumn: colStartIndex - 1,
+				endColumn: colStartIndex - 1,
+				startRow: from.row,
+				endRow: to.row
+			});
+			newSheetTransform = {
+				from: { ...from },
+				to: {
+					...to,
+					column: colStartIndex - 1,
+					columnOffset: selectionCell.endX - selectionCell.startX
+				}
+			};
+			newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
+		}
+		if (newSheetTransform && newTransform) return {
+			newSheetTransform,
+			newTransform,
+			axisAlignSheetTransform
+		};
+		return null;
+	}
+	_expandRow(rowStartIndex, rowEndIndex, options) {
+		const { sheetSkeletonParam, sheetTransform, transform, anchorType = "0" } = options;
+		const { skeleton } = sheetSkeletonParam;
+		const rowCount = rowEndIndex - rowStartIndex + 1;
+		const { from, to } = sheetTransform;
+		const { row: fromRow } = from;
+		const { row: toRow } = to;
+		if (anchorType === "2") return {
+			newSheetTransform: transformToDrawingPosition({ ...transform }, skeleton),
+			newTransform: transform,
+			axisAlignSheetTransform: transformToAxisAlignPosition({ ...transform }, skeleton)
+		};
+		let newSheetTransform = null;
+		let newTransform = null;
+		let axisAlignSheetTransform = null;
+		if (fromRow >= rowStartIndex) {
+			const selectionCell = attachRangeWithCoord(skeleton, {
+				startRow: rowStartIndex,
+				endRow: rowEndIndex,
+				startColumn: from.column,
+				endColumn: to.column
+			});
+			newTransform = {
+				...transform,
+				top: (transform.top || 0) + selectionCell.endY - selectionCell.startY
+			};
+			newSheetTransform = transformToDrawingPosition(newTransform, skeleton);
+			axisAlignSheetTransform = transformToAxisAlignPosition(newTransform, skeleton);
+		} else if (toRow >= rowEndIndex) if (anchorType === "1") {
+			newSheetTransform = {
+				from: { ...from },
+				to: {
+					...to,
+					row: toRow + rowCount
+				}
+			};
+			newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
+		} else return {
+			newSheetTransform: transformToDrawingPosition({ ...transform }, skeleton),
+			newTransform: transform,
+			axisAlignSheetTransform: transformToAxisAlignPosition({ ...transform }, skeleton)
+		};
+		if (newSheetTransform && newTransform) return {
+			newSheetTransform,
+			newTransform,
+			axisAlignSheetTransform
+		};
+		return null;
+	}
+	_shrinkRow(rowStartIndex, rowEndIndex, options) {
+		const { sheetSkeletonParam, sheetTransform, transform, anchorType = "0" } = options;
+		const { skeleton } = sheetSkeletonParam;
+		const rowCount = rowEndIndex - rowStartIndex + 1;
+		const { from, to } = sheetTransform;
+		const { row: fromRow } = from;
+		const { row: toRow } = to;
+		if (anchorType === "2") return {
+			newSheetTransform: transformToDrawingPosition({ ...transform }, skeleton),
+			newTransform: transform,
+			axisAlignSheetTransform: transformToAxisAlignPosition({ ...transform }, skeleton)
+		};
+		let newSheetTransform = null;
+		let newTransform = null;
+		let axisAlignSheetTransform = null;
+		if (fromRow > rowEndIndex) {
+			newSheetTransform = {
+				from: {
+					...from,
+					row: fromRow - rowCount
+				},
+				to: {
+					...to,
+					row: toRow - rowCount
+				}
+			};
+			newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
+		} else if (fromRow >= rowStartIndex && toRow <= rowEndIndex) return null;
+		else if (fromRow < rowStartIndex && toRow > rowEndIndex) if (anchorType === "1") {
+			newSheetTransform = {
+				from: { ...from },
+				to: {
+					...to,
+					row: toRow - rowCount
+				}
+			};
+			newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
+		} else return {
+			newSheetTransform: transformToDrawingPosition({ ...transform }, skeleton),
+			newTransform: transform,
+			axisAlignSheetTransform: transformToAxisAlignPosition({ ...transform }, skeleton)
+		};
+		else if (fromRow >= rowStartIndex && fromRow <= rowEndIndex) {
+			if (anchorType === "1") {
+				newSheetTransform = {
+					from: {
+						...from,
+						row: rowStartIndex,
+						rowOffset: 0
+					},
+					to: {
+						...to,
+						row: toRow - rowCount
+					}
+				};
+				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);
+			}
+		} else if (toRow >= rowStartIndex && toRow <= rowEndIndex && anchorType === "1") {
+			const selectionCell = attachRangeWithCoord(skeleton, {
+				startColumn: from.column,
+				endColumn: from.column,
+				startRow: rowStartIndex - 1,
+				endRow: rowStartIndex - 1
+			});
+			newSheetTransform = {
+				from: { ...from },
+				to: {
+					...to,
+					row: rowStartIndex - 1,
+					rowOffset: selectionCell.endY - selectionCell.startY
+				}
+			};
+			newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
+		}
+		if (newSheetTransform && newTransform) return {
+			newSheetTransform,
+			newTransform,
+			axisAlignSheetTransform
+		};
+		return null;
+	}
+	_sheetRefreshListener() {
+		this.disposeWithMe(this._commandService.onCommandExecuted((command) => {
+			if (!REFRESH_MUTATIONS.includes(command.id)) return;
+			queueMicrotask(() => {
+				const params = command.params;
+				const target = getSheetCommandTarget(this._univerInstanceService, params);
+				if (!target) return;
+				const { unitId, subUnitId, worksheet } = target;
+				let ranges = [];
+				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);
+			});
+		}));
+	}
+	_refreshDrawingTransform(command, unitId, subUnitId, ranges) {
+		var _this$_drawingManager;
+		const sheetSkeletonParam = this._getCalculatedSkeletonParam(unitId, subUnitId);
+		const drawingData = (_this$_drawingManager = this._drawingManagerService.getDrawingData(unitId, subUnitId)) !== null && _this$_drawingManager !== void 0 ? _this$_drawingManager : {};
+		const updateDrawings = [];
+		Object.keys(drawingData).forEach((drawingId) => {
+			const drawing = drawingData[drawingId];
+			const { sheetTransform, transform, anchorType = "0" } = drawing;
+			if (anchorType === "2") return true;
+			if (!sheetTransform) return true;
+			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 { startRow, endRow, startColumn, endColumn } = ranges[i];
+				if (Rectangle.intersects({
+					startRow,
+					endRow,
+					startColumn,
+					endColumn
+				}, {
+					startRow: fromRow,
+					endRow: toRow,
+					startColumn: fromColumn,
+					endColumn: toColumn
+				}) || fromRow > endRow || fromColumn > endColumn) {
+					const isPositionAnchor = anchorType === "0";
+					const newTransform = drawingPositionToTransform(sheetTransform, sheetSkeletonParam);
+					updateDrawings.push({
+						...drawing,
+						transform: {
+							...transform,
+							left: newTransform === null || newTransform === void 0 ? void 0 : newTransform.left,
+							top: newTransform === null || newTransform === void 0 ? void 0 : newTransform.top,
+							width: isPositionAnchor ? transform === null || transform === void 0 ? void 0 : transform.width : newTransform === null || newTransform === void 0 ? void 0 : newTransform.width,
+							height: isPositionAnchor ? transform === null || transform === void 0 ? void 0 : transform.height : newTransform === null || newTransform === void 0 ? void 0 : newTransform.height
+						}
+					});
+					break;
+				}
+			}
+		});
+		this._finalizePlan(unitId, subUnitId, updateDrawings, [], "refresh", command);
+	}
+};
+SheetDrawingTransformAffectedController = __decorate([
+	__decorateParam(0, ICommandService),
+	__decorateParam(1, Inject(SheetSkeletonService)),
+	__decorateParam(2, Inject(SheetInterceptorService)),
+	__decorateParam(3, Inject(SheetsSelectionsService)),
+	__decorateParam(4, ISheetDrawingService),
+	__decorateParam(5, IDrawingManagerService),
+	__decorateParam(6, IUniverInstanceService),
+	__decorateParam(7, Inject(SheetDrawingTransformPlanService))
+], SheetDrawingTransformAffectedController);
+
 //#endregion
 //#region src/plugin.ts
 let UniverSheetsDrawingPlugin = class UniverSheetsDrawingPlugin extends Plugin {
@@ -729,8 +2050,14 @@ let UniverSheetsDrawingPlugin = class UniverSheetsDrawingPlugin extends Plugin {
 		this._configService.setConfig(SHEETS_DRAWING_PLUGIN_CONFIG_KEY, rest);
 	}
 	onStarting() {
-		[[SheetsDrawingLoadController], [ISheetDrawingService, { useClass: SheetDrawingService }]].forEach((dependency) => this._injector.add(dependency));
+		[
+			[SheetsDrawingLoadController],
+			[SheetDrawingTransformPlanService],
+			[SheetDrawingTransformAffectedController],
+			[ISheetDrawingService, { useClass: SheetDrawingService }]
+		].forEach((dependency) => this._injector.add(dependency));
 		this._injector.get(SheetsDrawingLoadController);
+		this._injector.get(SheetDrawingTransformAffectedController);
 	}
 };
 _defineProperty(UniverSheetsDrawingPlugin, "pluginName", SHEET_DRAWING_PLUGIN);
@@ -744,4 +2071,4 @@ UniverSheetsDrawingPlugin = __decorate([
 ], UniverSheetsDrawingPlugin);
 
 //#endregion
-export { ClearSheetDrawingTransformerOperation, DrawingApplyType, ISheetDrawingService, InsertSheetDrawingCommand, RemoveSheetDrawingCommand, SHEET_DRAWING_PLUGIN, SetDrawingApplyMutation, SetDrawingArrangeCommand, SetSheetDrawingCommand, SheetDrawingAnchorType, SheetDrawingService, UniverSheetsDrawingPlugin, drawingPositionToTransform, isKnownSheetNonRotatableDrawingType, resolveSheetDrawingRotateEnabled, transformToAxisAlignPosition, transformToDrawingPosition };
+export { ClearSheetDrawingTransformerOperation, DrawingApplyType, ISheetDrawingService, InsertSheetDrawingCommand, RemoveSheetDrawingCommand, SHEET_DRAWING_PLUGIN, SetDrawingApplyMutation, SetDrawingArrangeCommand, SetSheetDrawingCommand, SheetDrawingAnchorType, SheetDrawingService, SheetDrawingTransformPlanService, UniverSheetsDrawingPlugin, drawingPositionToTransform, isKnownSheetNonRotatableDrawingType, resolveSheetDrawingRotateEnabled, transformToAxisAlignPosition, transformToDrawingPosition };