@univerjs/sheets-drawing 1.5.1 → 1.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/index.js CHANGED
@@ -1,7 +1,29 @@
1
- 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, UniverSheetsPlugin, attachRangeWithCoord, convertPositionCellToSheetOverGrid, convertPositionSheetOverGridToAbsolute, getSheetCommandTarget } from "@univerjs/sheets";
2
- import { ArrangeTypeEnum, CommandType, CustomCommandExecutionError, DependentOn, Disposable, DrawingTypeEnum, ICommandService, IConfigService, ILogService, IResourceManagerService, IUndoRedoService, IUniverInstanceService, Inject, Injector, Plugin, Rectangle, UniverInstanceType, createIdentifier, merge, sequenceExecute, toDisposable } from "@univerjs/core";
1
+ 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, UniverSheetsPlugin, attachRangeWithCoord, convertPositionSheetOverGridToAbsolute, getSheetCommandTarget } from "@univerjs/sheets";
2
+ import { ArrangeTypeEnum, CommandType, CustomCommandExecutionError, DependentOn, Disposable, DrawingTypeEnum, ICommandService, IConfigService, ILogService, IResourceManagerService, IUndoRedoService, IUniverInstanceService, Inject, Injector, JSON1, Optional, Plugin, Quantity, Rectangle, UniverInstanceType, createIdentifier, merge, sequenceExecute, toDisposable } from "@univerjs/core";
3
+ import { IRenderManagerService, getGroupState, getTransformBoundingBox, precisionTo } from "@univerjs/engine-render";
3
4
  import { IDrawingManagerService, UnitDrawingService, UniverDrawingPlugin, getOrCreateDrawingCopyPlan, resolveDrawingRotateEnabled } from "@univerjs/drawing";
4
- import { IRenderManagerService, Transform, Vector2, getGroupState } from "@univerjs/engine-render";
5
+
6
+ // src/basics/drawing-reference.ts
7
+ /** Map an anchor marker through a row/column insertion or deletion. */
8
+ function transformSheetDrawingReference(marker, reference) {
9
+ const { axis, action, start, end, limit, boundaryOffset } = reference;
10
+ const offset = axis === "row" ? "rowOffset" : "columnOffset";
11
+ if (!["row", "column"].includes(axis) || !["insert", "remove"].includes(action) || !Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start || !Number.isInteger(limit) || limit <= 0 || !Number.isFinite(boundaryOffset) || boundaryOffset < 0 || !Number.isInteger(marker[axis]) || marker[axis] < 0 || !Number.isFinite(marker[offset])) throw new Error("Invalid drawing reference change.");
12
+ const result = { ...marker };
13
+ const count = end - start + 1;
14
+ if (action === "insert") {
15
+ if (result[axis] >= start) result[axis] += count;
16
+ } else if (result[axis] > end) result[axis] -= count;
17
+ else if (result[axis] >= start) {
18
+ result[axis] = start;
19
+ result[offset] = 0;
20
+ }
21
+ if (result[axis] >= limit) {
22
+ result[axis] = limit - 1;
23
+ result[offset] = boundaryOffset;
24
+ }
25
+ return result;
26
+ }
5
27
 
6
28
  // src/basics/transform-position.ts
7
29
  function drawingPositionToTransform(position, sheetSkeletonParam) {
@@ -57,15 +79,40 @@ function transformToDrawingPosition(transform, skeleton) {
57
79
  */
58
80
  function transformToAxisAlignPosition(transform, skeleton) {
59
81
  const { left = 0, top = 0, width = 0, height = 0, angle = 0 } = transform;
60
- const norm = (angle % 360 + 360) % 360;
61
- if (!(norm >= 45 && norm < 135 || norm >= 225 && norm < 315)) return transformToDrawingPosition(transform, skeleton);
62
- return transformToDrawingPosition({
63
- ...transform,
64
- left: left + width / 2 - height / 2,
65
- top: top + height / 2 - width / 2,
82
+ const { from, to } = transformToDrawingPosition(isDrawingAxisSwapped(angle) ? {
83
+ left: left + (width - height) / 2,
84
+ top: top + (height - width) / 2,
66
85
  width: height,
67
86
  height: width
87
+ } : {
88
+ left,
89
+ top,
90
+ width,
91
+ height
68
92
  }, skeleton);
93
+ return {
94
+ from,
95
+ to
96
+ };
97
+ }
98
+ function isDrawingAxisSwapped(angle = 0) {
99
+ const normalized = (angle % 360 + 360) % 360;
100
+ return normalized >= 45 && normalized < 135 || normalized >= 225 && normalized < 315;
101
+ }
102
+
103
+ // \0@oxc-project+runtime@0.158.0/helpers/esm/decorateParam.js
104
+ function __decorateParam(paramIndex, decorator) {
105
+ return function(target, key) {
106
+ decorator(target, key, paramIndex);
107
+ };
108
+ }
109
+
110
+ // \0@oxc-project+runtime@0.158.0/helpers/esm/decorate.js
111
+ function __decorate(decorators, target, key, desc) {
112
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
113
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
114
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
115
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
69
116
  }
70
117
 
71
118
  // src/services/sheet-drawing.service.ts
@@ -84,9 +131,510 @@ let SheetDrawingAnchorType = /* @__PURE__ */ function(SheetDrawingAnchorType) {
84
131
  SheetDrawingAnchorType["None"] = "2";
85
132
  return SheetDrawingAnchorType;
86
133
  }({});
87
- var SheetDrawingService = class extends UnitDrawingService {};
134
+ let SheetDrawingService = class SheetDrawingService extends UnitDrawingService {
135
+ constructor(_sheetSkeletonService) {
136
+ super();
137
+ this._sheetSkeletonService = _sheetSkeletonService;
138
+ }
139
+ getBatchAddOp(drawings) {
140
+ return super.getBatchAddOp(drawings.map((drawing) => this._normalizeDrawing(drawing)));
141
+ }
142
+ getBatchUpdateOp(drawings) {
143
+ return super.getBatchUpdateOp(drawings.map((drawing) => {
144
+ if (!drawing.sheetTransform) return this._normalizeDrawing(drawing);
145
+ const current = this.getDrawingByParam(drawing);
146
+ return this._normalizeDrawing({
147
+ ...current,
148
+ ...drawing,
149
+ transform: {
150
+ ...current === null || current === void 0 ? void 0 : current.transform,
151
+ ...drawing.transform
152
+ },
153
+ axisAlignSheetTransform: drawing.axisAlignSheetTransform
154
+ });
155
+ }));
156
+ }
157
+ _normalizeDrawing(drawing) {
158
+ var _drawing$axisAlignShe, _drawing$transform, _this$_sheetSkeletonS;
159
+ const hasGeometry = ((_drawing$axisAlignShe = drawing.axisAlignSheetTransform) === null || _drawing$axisAlignShe === void 0 ? void 0 : _drawing$axisAlignShe.from) && ((_drawing$transform = drawing.transform) === null || _drawing$transform === void 0 ? void 0 : _drawing$transform.width) != null && drawing.transform.height != null;
160
+ const skeleton = drawing.sheetTransform && !hasGeometry && drawing.anchorType !== "2" && !drawing.groupId ? (_this$_sheetSkeletonS = this._sheetSkeletonService) === null || _this$_sheetSkeletonS === void 0 ? void 0 : _this$_sheetSkeletonS.ensureSkeleton(drawing.unitId, drawing.subUnitId) : void 0;
161
+ const normalized = normalizeSheetDrawing(drawing, skeleton);
162
+ if (!normalized.sheetTransform) {
163
+ const { sheetTransform: _legacy, ...model } = normalized;
164
+ return model;
165
+ }
166
+ return normalized;
167
+ }
168
+ };
169
+ SheetDrawingService = __decorate([__decorateParam(0, Optional(SheetSkeletonService))], SheetDrawingService);
88
170
  const ISheetDrawingService = createIdentifier("sheets-drawing.sheet-drawing.service");
89
171
 
172
+ // src/services/sheet-drawing-placement.ts
173
+ const PLACEMENT_ERROR = {
174
+ CELL_INVALID: "SHEET_DRAWING_PLACEMENT_CELL_INVALID",
175
+ EXTENT_INVALID: "SHEET_DRAWING_PLACEMENT_EXTENT_INVALID",
176
+ KIND_INVALID: "SHEET_DRAWING_PLACEMENT_KIND_INVALID",
177
+ POSITION_INVALID: "SHEET_DRAWING_PLACEMENT_POSITION_INVALID"
178
+ };
179
+ function getSheetDrawingPositionAnchorField(drawing) {
180
+ const axis = drawing.axisAlignSheetTransform;
181
+ const from = axis === null || axis === void 0 ? void 0 : axis.from;
182
+ if (!from || validateCellPosition(from)) return "sheetTransform";
183
+ if (axis.to && validateCellPosition(axis.to) && (from.row > 0 && from.rowOffset < 0 || from.column > 0 && from.columnOffset < 0)) return "sheetTransform";
184
+ return "axisAlignSheetTransform";
185
+ }
186
+ function getAxisAlignedDrawingPosition(drawing, usesImportedMarkers = false) {
187
+ if (usesImportedMarkers) return drawing.axisAlignSheetTransform ?? drawing.sheetTransform;
188
+ if (drawing.anchorType === "1" || getSheetDrawingPositionAnchorField(drawing) === "axisAlignSheetTransform") return drawing.axisAlignSheetTransform;
189
+ }
190
+ /** Reconstruct the unrotated coordinates expected by legacy drawing APIs. */
191
+ function getLegacySheetDrawingPosition(drawing, skeleton) {
192
+ const transform = getSheetDrawingTransformWithOrientation(drawing);
193
+ const position = transformToDrawingPosition(transform, skeleton);
194
+ const anchorType = drawing.anchorType ?? "0";
195
+ if (anchorType !== "2" && !isDrawingAxisSwapped(transform.angle)) {
196
+ const anchor = drawing.axisAlignSheetTransform;
197
+ if (anchor === null || anchor === void 0 ? void 0 : anchor.from) position.from = { ...anchor.from };
198
+ if (anchorType === "1" && (anchor === null || anchor === void 0 ? void 0 : anchor.to)) position.to = { ...anchor.to };
199
+ }
200
+ return position;
201
+ }
202
+ /** Convert old position and orientation fields at the drawing model boundary. */
203
+ function normalizeSheetDrawing(drawing, skeleton) {
204
+ const { sheetTransform, axisAlignSheetTransform, ...model } = drawing;
205
+ const axisHasOrientation = axisAlignSheetTransform && Object.keys(axisAlignSheetTransform).some((key) => key !== "from" && key !== "to");
206
+ if (!sheetTransform && !axisHasOrientation) return drawing;
207
+ const transform = getSheetDrawingTransformWithOrientation(drawing);
208
+ if (skeleton && !drawing.groupId && drawing.anchorType !== "2") {
209
+ const result = tryRefreshSheetDrawingPlacement({
210
+ ...drawing,
211
+ transform
212
+ }, skeleton);
213
+ if (!result.ok) return drawing;
214
+ return {
215
+ ...model,
216
+ transform: result.drawing.transform,
217
+ axisAlignSheetTransform: result.drawing.axisAlignSheetTransform
218
+ };
219
+ }
220
+ const markers = axisAlignSheetTransform ?? sheetTransform;
221
+ if (!markers || !axisAlignSheetTransform && drawing.anchorType !== "2" && !drawing.groupId) return {
222
+ ...drawing,
223
+ transform
224
+ };
225
+ return {
226
+ ...model,
227
+ transform,
228
+ axisAlignSheetTransform: {
229
+ from: markers.from,
230
+ to: markers.to
231
+ }
232
+ };
233
+ }
234
+ function getSheetDrawingPlacement(drawing, skeleton) {
235
+ var _current$transform, _current$transform2;
236
+ const anchorType = drawing.anchorType ?? "0";
237
+ if (anchorType === "2") {
238
+ var _drawing$transform, _drawing$transform2, _drawing$transform3, _drawing$transform4;
239
+ return {
240
+ kind: "2",
241
+ left: ((_drawing$transform = drawing.transform) === null || _drawing$transform === void 0 ? void 0 : _drawing$transform.left) ?? 0,
242
+ top: ((_drawing$transform2 = drawing.transform) === null || _drawing$transform2 === void 0 ? void 0 : _drawing$transform2.top) ?? 0,
243
+ width: ((_drawing$transform3 = drawing.transform) === null || _drawing$transform3 === void 0 ? void 0 : _drawing$transform3.width) ?? 0,
244
+ height: ((_drawing$transform4 = drawing.transform) === null || _drawing$transform4 === void 0 ? void 0 : _drawing$transform4.height) ?? 0
245
+ };
246
+ }
247
+ const current = skeleton && !getAxisAlignedDrawingPosition(drawing) ? normalizeSheetDrawing(drawing, skeleton) : drawing;
248
+ const position = getAxisAlignedDrawingPosition(current) ?? current.sheetTransform ?? current.axisAlignSheetTransform;
249
+ if (anchorType === "1") return {
250
+ kind: "1",
251
+ from: { ...position.from },
252
+ to: { ...position.to }
253
+ };
254
+ return {
255
+ kind: "0",
256
+ from: { ...position.from },
257
+ width: ((_current$transform = current.transform) === null || _current$transform === void 0 ? void 0 : _current$transform.width) ?? 0,
258
+ height: ((_current$transform2 = current.transform) === null || _current$transform2 === void 0 ? void 0 : _current$transform2.height) ?? 0
259
+ };
260
+ }
261
+ function applySheetDrawingPlacement(drawing, input, skeleton) {
262
+ return resolveSheetDrawingPlacement(drawing, normalizePlacement(input, skeleton, requiresDrawingArea(drawing)), skeleton, !("bounds" in input));
263
+ }
264
+ /** Place a batch at the logical start corner of a Chart Sheet, preserving its relative geometry. */
265
+ function transformDrawingsToChartSheet(drawings, chartSheetBounds, rightToLeft) {
266
+ if (validateBounds(chartSheetBounds, true)) return null;
267
+ if (!drawings.length) return [];
268
+ const bounds = [];
269
+ for (const drawing of drawings) {
270
+ const state = drawing.transform;
271
+ if (!state || validateBounds(state, requiresDrawingArea(drawing)) || [
272
+ state.angle,
273
+ state.skewX,
274
+ state.skewY,
275
+ state.scaleX,
276
+ state.scaleY
277
+ ].some((value) => value !== void 0 && !Number.isFinite(value))) return null;
278
+ bounds.push(getTransformBoundingBox(state));
279
+ }
280
+ const group = getGroupState(0, 0, bounds);
281
+ const scale = Math.min(1, group.width ? chartSheetBounds.width / group.width : 1, group.height ? chartSheetBounds.height / group.height : 1);
282
+ const left = rightToLeft ? chartSheetBounds.left + chartSheetBounds.width - group.width * scale : chartSheetBounds.left;
283
+ return drawings.map((drawing) => applySheetDrawingPlacement(drawing, {
284
+ kind: "2",
285
+ left: left + (drawing.transform.left - group.left) * scale,
286
+ top: chartSheetBounds.top + (drawing.transform.top - group.top) * scale,
287
+ width: drawing.transform.width * scale,
288
+ height: drawing.transform.height * scale
289
+ }));
290
+ }
291
+ /** Refresh layout-derived geometry without changing the drawing's anchor semantics. */
292
+ function refreshSheetDrawingPlacement(drawing, skeleton) {
293
+ const result = tryRefreshSheetDrawingPlacement(drawing, skeleton);
294
+ if (!result.ok) throw createPlacementError(result);
295
+ return result.drawing;
296
+ }
297
+ /** Validate authoritative markers; a one-cell endpoint can be rebuilt from its fixed extent. */
298
+ function validateSheetDrawingPlacement(drawing) {
299
+ if (!drawing || typeof drawing !== "object") return {
300
+ ok: false,
301
+ reason: PLACEMENT_ERROR.KIND_INVALID
302
+ };
303
+ const anchorType = drawing.anchorType ?? "0";
304
+ if (anchorType === "2") return;
305
+ if (anchorType !== "0" && anchorType !== "1") return {
306
+ ok: false,
307
+ reason: PLACEMENT_ERROR.KIND_INVALID
308
+ };
309
+ if (anchorType === "0") {
310
+ var _drawing$getSheetDraw, _drawing$transform5, _drawing$transform6;
311
+ return validateCellPosition((_drawing$getSheetDraw = drawing[getSheetDrawingPositionAnchorField(drawing)]) === null || _drawing$getSheetDraw === void 0 ? void 0 : _drawing$getSheetDraw.from) ?? validateExtent(((_drawing$transform5 = drawing.transform) === null || _drawing$transform5 === void 0 ? void 0 : _drawing$transform5.width) ?? 0, ((_drawing$transform6 = drawing.transform) === null || _drawing$transform6 === void 0 ? void 0 : _drawing$transform6.height) ?? 0, requiresDrawingArea(drawing));
312
+ }
313
+ const markers = drawing.axisAlignSheetTransform ?? drawing.sheetTransform;
314
+ return validateCellPosition(markers === null || markers === void 0 ? void 0 : markers.from) ?? validateCellPosition(markers === null || markers === void 0 ? void 0 : markers.to);
315
+ }
316
+ /** Expected snapshot errors are results; unexpected calculation failures are caught by the task owner. */
317
+ function tryRefreshSheetDrawingPlacement(drawing, skeleton) {
318
+ var _drawing$transform7, _drawing$transform8, _resolved$transform, _resolved$transform2;
319
+ const deriveFixedExtent = drawing && (drawing.anchorType ?? "0") === "0" && isUnprojectedImage(drawing);
320
+ const failure = validateSheetDrawingPlacement(deriveFixedExtent ? {
321
+ ...drawing,
322
+ anchorType: "1"
323
+ } : drawing);
324
+ if (failure) return failure;
325
+ if (drawing.anchorType === "2") return {
326
+ ok: true,
327
+ drawing
328
+ };
329
+ const resolvesBoth = deriveFixedExtent || drawing.anchorType === "1";
330
+ const axisAnchor = getAxisAlignedDrawingPosition(drawing, resolvesBoth && isUnprojectedImage(drawing));
331
+ const anchor = axisAnchor ?? drawing.sheetTransform;
332
+ const resolved = resolveSheetDrawingPlacement(drawing, resolvesBoth ? {
333
+ kind: "1",
334
+ from: anchor.from,
335
+ to: anchor.to
336
+ } : {
337
+ kind: "0",
338
+ from: anchor.from,
339
+ width: ((_drawing$transform7 = drawing.transform) === null || _drawing$transform7 === void 0 ? void 0 : _drawing$transform7.width) ?? 0,
340
+ height: ((_drawing$transform8 = drawing.transform) === null || _drawing$transform8 === void 0 ? void 0 : _drawing$transform8.height) ?? 0
341
+ }, skeleton, Boolean(axisAnchor));
342
+ const extentFailure = validateExtent(((_resolved$transform = resolved.transform) === null || _resolved$transform === void 0 ? void 0 : _resolved$transform.width) ?? 0, ((_resolved$transform2 = resolved.transform) === null || _resolved$transform2 === void 0 ? void 0 : _resolved$transform2.height) ?? 0, requiresDrawingArea(drawing), !deriveFixedExtent);
343
+ if (extentFailure) return extentFailure;
344
+ return {
345
+ ok: true,
346
+ drawing: {
347
+ ...drawing,
348
+ sheetTransform: void 0,
349
+ transform: resolved.transform,
350
+ axisAlignSheetTransform: resolved.axisAlignSheetTransform
351
+ }
352
+ };
353
+ }
354
+ function requiresDrawingArea(drawing) {
355
+ return drawing.drawingType === DrawingTypeEnum.DRAWING_IMAGE || drawing.drawingType === DrawingTypeEnum.DRAWING_DOM;
356
+ }
357
+ function isUnprojectedImage(drawing) {
358
+ const { transform, drawingType } = drawing;
359
+ return drawingType === DrawingTypeEnum.DRAWING_IMAGE && (transform === null || transform === void 0 ? void 0 : transform.left) === 0 && transform.top === 0 && transform.width === 0 && transform.height === 0;
360
+ }
361
+ /** Preserve cell orientation when an imported pixel cache is incomplete. */
362
+ function getSheetDrawingTransformWithOrientation(drawing) {
363
+ const transform = { ...drawing.transform };
364
+ if (drawing.groupId) return transform;
365
+ for (const key of [
366
+ "angle",
367
+ "flipX",
368
+ "flipY",
369
+ "skewX",
370
+ "skewY"
371
+ ]) {
372
+ var _drawing$sheetTransfo, _drawing$axisAlignShe, _drawing$sheetTransfo2;
373
+ if (drawing.anchorType === "2" && transform[key] !== void 0) continue;
374
+ const legacy = ((_drawing$sheetTransfo = drawing.sheetTransform) === null || _drawing$sheetTransfo === void 0 ? void 0 : _drawing$sheetTransfo[key]) ?? ((_drawing$axisAlignShe = drawing.axisAlignSheetTransform) === null || _drawing$axisAlignShe === void 0 ? void 0 : _drawing$axisAlignShe[key]);
375
+ const legacySupplied = ((_drawing$sheetTransfo2 = drawing.sheetTransform) === null || _drawing$sheetTransfo2 === void 0 ? void 0 : _drawing$sheetTransfo2[key]) !== void 0;
376
+ if (legacy !== void 0 && (legacySupplied ? legacy || transform[key] !== void 0 : legacy && transform[key] === void 0)) Object.assign(transform, { [key]: legacy });
377
+ }
378
+ return transform;
379
+ }
380
+ function resolveSheetDrawingPlacement(drawing, placement, skeleton, usesAxisMarkers) {
381
+ const existingTransform = getSheetDrawingTransformWithOrientation(drawing);
382
+ const { sheetTransform: _legacy, ...model } = drawing;
383
+ if (placement.kind === "2") {
384
+ const transform = withExistingTransform(existingTransform, placement);
385
+ return {
386
+ ...model,
387
+ anchorType: "2",
388
+ transform,
389
+ axisAlignSheetTransform: absoluteSheetTransform(placement)
390
+ };
391
+ }
392
+ if (!skeleton) throw new Error("SHEET_DRAWING_PLACEMENT_SKELETON_REQUIRED");
393
+ if (placement.kind === "0") {
394
+ const { width, height } = placement;
395
+ const origin = projectCellMarker(placement.from, skeleton);
396
+ const swapped = isDrawingAxisSwapped(existingTransform.angle);
397
+ if (usesAxisMarkers && swapped) {
398
+ origin.left = precisionTo(origin.left + (height - width) / 2, 6);
399
+ origin.top = precisionTo(origin.top + (width - height) / 2, 6);
400
+ }
401
+ const transform = withExistingTransform(existingTransform, {
402
+ ...origin,
403
+ width,
404
+ height
405
+ });
406
+ const axis = transformToAxisAlignPosition(transform, skeleton);
407
+ return {
408
+ ...model,
409
+ anchorType: "0",
410
+ transform,
411
+ axisAlignSheetTransform: {
412
+ from: { ...usesAxisMarkers || !swapped ? placement.from : axis.from },
413
+ to: axis.to
414
+ }
415
+ };
416
+ }
417
+ const swapped = isDrawingAxisSwapped(existingTransform.angle);
418
+ const from = projectCellMarker(placement.from, skeleton);
419
+ const to = projectCellMarker(placement.to, skeleton);
420
+ const bounds = {
421
+ left: from.left,
422
+ top: from.top,
423
+ width: precisionTo(to.left - from.left, 6),
424
+ height: precisionTo(to.top - from.top, 6)
425
+ };
426
+ let transform = withExistingTransform(existingTransform, bounds);
427
+ if (usesAxisMarkers && swapped) transform = {
428
+ ...transform,
429
+ left: precisionTo(bounds.left + bounds.width / 2 - bounds.height / 2, 6),
430
+ top: precisionTo(bounds.top + bounds.height / 2 - bounds.width / 2, 6),
431
+ width: bounds.height,
432
+ height: bounds.width
433
+ };
434
+ const markers = usesAxisMarkers || !swapped ? placement : transformToAxisAlignPosition(transform, skeleton);
435
+ return {
436
+ ...model,
437
+ anchorType: "1",
438
+ transform,
439
+ axisAlignSheetTransform: {
440
+ from: { ...markers.from },
441
+ to: { ...markers.to }
442
+ }
443
+ };
444
+ }
445
+ function projectCellMarker(position, skeleton) {
446
+ const cell = skeleton.getNoMergeCellWithCoordByIndex(position.row, position.column);
447
+ const { worksheet } = skeleton;
448
+ const lastColumn = position.column === worksheet.getColumnCount() - 1;
449
+ const lastRow = position.row === worksheet.getRowCount() - 1;
450
+ return {
451
+ left: precisionTo(cell.startX + projectCellOffset(position.columnOffset, cell.endX - cell.startX, lastColumn), 6),
452
+ top: precisionTo(cell.startY + projectCellOffset(position.rowOffset, cell.endY - cell.startY, lastRow), 6)
453
+ };
454
+ }
455
+ function projectCellOffset(offset, extent, isLastCell) {
456
+ if (extent === 0) return 0;
457
+ return isLastCell ? offset : Math.min(offset, extent);
458
+ }
459
+ /**
460
+ * Normalize exact markers or model-space bounds to the authoritative
461
+ * Position, Both, or None Placement.
462
+ */
463
+ function normalizeSheetDrawingPlacement(input, skeleton) {
464
+ return normalizePlacement(input, skeleton, false);
465
+ }
466
+ function normalizePlacement(input, skeleton, requiresArea) {
467
+ if (!("bounds" in input)) {
468
+ assertValidPlacement(validatePlacement(input, requiresArea));
469
+ if (input.kind === "1" && skeleton) assertValidPlacement(validateBounds(convertPositionSheetOverGridToAbsolute(skeleton.worksheet.getUnitId(), skeleton.worksheet.getSheetId(), {
470
+ from: input.from,
471
+ to: input.to
472
+ }, skeleton), requiresArea));
473
+ return input;
474
+ }
475
+ assertValidPlacement(validateBounds(input.bounds, requiresArea));
476
+ if (input.kind === "2") return {
477
+ kind: "2",
478
+ ...input.bounds
479
+ };
480
+ if (!skeleton) throw new Error("SHEET_DRAWING_PLACEMENT_SKELETON_REQUIRED");
481
+ const sheetTransform = transformToDrawingPosition(input.bounds, skeleton);
482
+ if (input.kind === "0") return {
483
+ kind: "0",
484
+ from: sheetTransform.from,
485
+ width: input.bounds.width,
486
+ height: input.bounds.height
487
+ };
488
+ if (input.kind === "1") return {
489
+ kind: "1",
490
+ from: sheetTransform.from,
491
+ to: sheetTransform.to
492
+ };
493
+ throw new Error(PLACEMENT_ERROR.KIND_INVALID);
494
+ }
495
+ function withExistingTransform(current, bounds) {
496
+ return {
497
+ ...current,
498
+ left: bounds.left,
499
+ top: bounds.top,
500
+ width: bounds.width,
501
+ height: bounds.height
502
+ };
503
+ }
504
+ function absoluteSheetTransform(placement) {
505
+ return {
506
+ from: {
507
+ column: 0,
508
+ columnOffset: placement.left,
509
+ row: 0,
510
+ rowOffset: placement.top
511
+ },
512
+ to: {
513
+ column: 0,
514
+ columnOffset: placement.left + placement.width,
515
+ row: 0,
516
+ rowOffset: placement.top + placement.height
517
+ }
518
+ };
519
+ }
520
+ function validatePlacement(placement, requiresArea) {
521
+ if (placement.kind === "0") return validateCellPosition(placement.from) ?? validateExtent(placement.width, placement.height, requiresArea);
522
+ if (placement.kind === "1") return validateCellPosition(placement.from) ?? validateCellPosition(placement.to);
523
+ if (placement.kind === "2") {
524
+ if (!Number.isFinite(placement.left) || !Number.isFinite(placement.top)) return {
525
+ ok: false,
526
+ reason: PLACEMENT_ERROR.POSITION_INVALID
527
+ };
528
+ return validateExtent(placement.width, placement.height, requiresArea);
529
+ }
530
+ return {
531
+ ok: false,
532
+ reason: PLACEMENT_ERROR.KIND_INVALID
533
+ };
534
+ }
535
+ function validateBounds(bounds, requiresArea) {
536
+ if (!bounds || !Number.isFinite(bounds.left) || !Number.isFinite(bounds.top)) return {
537
+ ok: false,
538
+ reason: PLACEMENT_ERROR.POSITION_INVALID
539
+ };
540
+ return validateExtent(bounds.width, bounds.height, requiresArea);
541
+ }
542
+ function validateCellPosition(position) {
543
+ if (!position || !Number.isInteger(position.row) || !Number.isInteger(position.column) || position.row < 0 || position.column < 0 || !Number.isFinite(position.rowOffset) || !Number.isFinite(position.columnOffset)) return {
544
+ ok: false,
545
+ reason: PLACEMENT_ERROR.CELL_INVALID
546
+ };
547
+ }
548
+ function validateExtent(width, height, requiresArea, allowCollapsed = false) {
549
+ const hasInvalidZeroExtent = !allowCollapsed && (requiresArea ? width === 0 || height === 0 : width === 0 && height === 0);
550
+ if (!Number.isFinite(width) || !Number.isFinite(height) || width < 0 || height < 0 || hasInvalidZeroExtent) return {
551
+ ok: false,
552
+ reason: PLACEMENT_ERROR.EXTENT_INVALID,
553
+ details: {
554
+ width,
555
+ height
556
+ }
557
+ };
558
+ }
559
+ function assertValidPlacement(failure) {
560
+ if (failure) throw createPlacementError(failure);
561
+ }
562
+ function createPlacementError(failure) {
563
+ const error = failure.reason === PLACEMENT_ERROR.POSITION_INVALID ? new TypeError(failure.reason) : new Error(failure.reason);
564
+ return Object.assign(error, failure.details);
565
+ }
566
+
567
+ // src/services/sheet-drawing-changeset.ts
568
+ function isLegacyDrawing(value) {
569
+ return value !== void 0 && value !== null && typeof value === "object" && "sheetTransform" in value;
570
+ }
571
+ function hasLegacyDrawingInInsert(value, path) {
572
+ if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
573
+ if (path.length === 4) return path[2] === "data" && isLegacyDrawing(value);
574
+ if (path.length === 3) return path[2] === "data" && Object.values(value).some(isLegacyDrawing);
575
+ if (path.length === 2) return value.data !== void 0 && hasLegacyDrawingInInsert(value.data, [...path, "data"]);
576
+ return Object.entries(value).some(([key, child]) => hasLegacyDrawingInInsert(child, [...path, key]));
577
+ }
578
+ /** Only snapshot replay may apply updates authored against the old drawing format. */
579
+ function assertCurrentSheetDrawingEdit({ op, reference }) {
580
+ if ((reference === null || reference === void 0 ? void 0 : reference.legacyPositionDrawingIds) !== void 0) throw new Error("Live sheet drawing edits require the current anchor format.");
581
+ const cursor = JSON1.type.readCursor(op);
582
+ cursor.traverse(null, (component) => {
583
+ const path = cursor.getPath();
584
+ if (path[2] === "data" && path[4] === "sheetTransform" || path.length <= 4 && component.i !== void 0 && hasLegacyDrawingInInsert(component.i, path)) throw new Error("Live sheet drawing edits require the current anchor format.");
585
+ });
586
+ }
587
+ /** Translate old marker edits in persisted history against a detached view. */
588
+ function normalizeHistoricalSheetDrawingEdit(op, unitId, subUnitId, getDrawing, getSkeleton) {
589
+ JSON1.type.checkValidOp(op);
590
+ const cursor = JSON1.type.readCursor(op);
591
+ const legacy = /* @__PURE__ */ new Map();
592
+ const authoredAxis = /* @__PURE__ */ new Set();
593
+ cursor.traverse(null, (component) => {
594
+ const path = cursor.getPath();
595
+ const drawingId = getDrawingId(path, unitId, subUnitId);
596
+ if (drawingId === void 0) return;
597
+ const field = path[4];
598
+ if (field === "axisAlignSheetTransform") authoredAxis.add(drawingId);
599
+ if (field === "sheetTransform") legacy.set(drawingId, Boolean(legacy.get(drawingId) || path.length > 5 || component.r !== void 0));
600
+ });
601
+ if (!legacy.size) return op;
602
+ const skeleton = getSkeleton();
603
+ const canonical = JSON1.type.writeCursor();
604
+ const legacyOps = new Map(Array.from(legacy.keys(), (id) => [id, JSON1.type.writeCursor()]));
605
+ cursor.traverse(null, (component) => {
606
+ const path = cursor.getPath();
607
+ const drawingId = getDrawingId(path, unitId, subUnitId);
608
+ const writer = drawingId === void 0 ? void 0 : legacyOps.get(drawingId);
609
+ if (writer) writer.mergeTree([...path.slice(4), component]);
610
+ else canonical.mergeTree([...path, component]);
611
+ });
612
+ for (const [drawingId, writer] of legacyOps) {
613
+ const current = getDrawing(drawingId);
614
+ if (!current) throw new Error("Missing drawing for legacy placement edit.");
615
+ const view = { ...current };
616
+ if (!view.sheetTransform && legacy.get(drawingId) && skeleton) view.sheetTransform = getLegacySheetDrawingPosition(current, skeleton);
617
+ const updated = { ...JSON1.type.apply(view, writer.get()) };
618
+ if (updated.sheetTransform && !authoredAxis.has(drawingId)) Reflect.deleteProperty(updated, "axisAlignSheetTransform");
619
+ const { sheetTransform: _legacy, ...drawing } = skeleton && !updated.groupId && updated.anchorType !== "2" ? refreshSheetDrawingPlacement(updated, skeleton) : normalizeSheetDrawing(updated);
620
+ canonical.mergeTree([
621
+ unitId,
622
+ subUnitId,
623
+ "data",
624
+ drawingId,
625
+ {
626
+ r: true,
627
+ i: drawing
628
+ }
629
+ ]);
630
+ }
631
+ return canonical.get();
632
+ }
633
+ function getDrawingId(path, unitId, subUnitId) {
634
+ const [unit, sheet, root, id] = path;
635
+ return unit === unitId && sheet === subUnitId && root === "data" && typeof id === "string" ? id : void 0;
636
+ }
637
+
90
638
  // src/commands/mutations/set-drawing-apply.mutation.ts
91
639
  let DrawingApplyType = /* @__PURE__ */ function(DrawingApplyType) {
92
640
  DrawingApplyType[DrawingApplyType["INSERT"] = 0] = "INSERT";
@@ -97,15 +645,94 @@ let DrawingApplyType = /* @__PURE__ */ function(DrawingApplyType) {
97
645
  DrawingApplyType[DrawingApplyType["UNGROUP"] = 5] = "UNGROUP";
98
646
  return DrawingApplyType;
99
647
  }({});
648
+ function needsPlacementHydration(drawing) {
649
+ var _drawing$transform, _drawing$transform2;
650
+ const oneCell = (drawing.anchorType ?? "0") === "0";
651
+ return Boolean(drawing.sheetTransform) || !((_drawing$transform = drawing.transform) === null || _drawing$transform === void 0 ? void 0 : _drawing$transform.width) && !((_drawing$transform2 = drawing.transform) === null || _drawing$transform2 === void 0 ? void 0 : _drawing$transform2.height) || oneCell && Boolean(validateSheetDrawingPlacement({
652
+ ...drawing,
653
+ anchorType: "1"
654
+ }));
655
+ }
656
+ function refreshReceivedDrawings(accessor, params, hydrateOnly, legacyPositionDrawings) {
657
+ var _accessor$get;
658
+ if (params.type === 1 || params.type === 3 || !Array.isArray(params.objects) || !params.objects.length) return;
659
+ const skeleton = (_accessor$get = accessor.get(SheetSkeletonService, Quantity.OPTIONAL)) === null || _accessor$get === void 0 ? void 0 : _accessor$get.ensureSkeleton(params.unitId, params.subUnitId);
660
+ if (!skeleton) return;
661
+ const dimensionsChanged = skeleton.rowHeightAccumulation.length !== skeleton.worksheet.getRowCount() || skeleton.columnWidthAccumulation.length !== skeleton.worksheet.getColumnCount();
662
+ if (params.recalculate || params.reference && dimensionsChanged) skeleton.makeDirty(true);
663
+ skeleton.calculate();
664
+ const service = accessor.get(ISheetDrawingService);
665
+ const drawings = [];
666
+ const objects = params.type === 4 || params.type === 5 ? params.objects.flatMap(({ parent, children }) => [parent, ...children]) : params.objects;
667
+ for (const object of objects) {
668
+ const drawing = service.getDrawingByParam(object);
669
+ if (!drawing) continue;
670
+ if (hydrateOnly && !needsPlacementHydration(drawing)) continue;
671
+ try {
672
+ if (drawing.groupId || drawing.anchorType === "2") {
673
+ const normalized = normalizeSheetDrawing(drawing);
674
+ if (normalized !== drawing) drawings.push({
675
+ ...normalized,
676
+ sheetTransform: void 0
677
+ });
678
+ continue;
679
+ }
680
+ let placementSource = drawing;
681
+ if (drawing.sheetTransform && legacyPositionDrawings.includes(drawing.drawingId)) {
682
+ placementSource = { ...drawing };
683
+ Reflect.deleteProperty(placementSource, "axisAlignSheetTransform");
684
+ }
685
+ const result = tryRefreshSheetDrawingPlacement(placementSource, skeleton);
686
+ if (result.ok) drawings.push(result.drawing);
687
+ else accessor.get(ILogService).warn("[SetDrawingApplyMutation]", "Skipping invalid drawing placement", object, result);
688
+ } catch (error) {
689
+ accessor.get(ILogService).error("[SetDrawingApplyMutation]", "Drawing placement refresh failed", object, error);
690
+ }
691
+ }
692
+ if (drawings.length) {
693
+ service.refreshTransform(drawings, false);
694
+ accessor.get(IDrawingManagerService).refreshTransform(drawings, false);
695
+ }
696
+ }
100
697
  const SetDrawingApplyMutation = {
101
698
  id: "sheet.mutation.set-drawing-apply",
102
699
  type: CommandType.MUTATION,
103
- handler: (accessor, params) => {
700
+ handler: (accessor, params, options) => {
104
701
  const drawingManagerService = accessor.get(IDrawingManagerService);
105
702
  const sheetDrawingService = accessor.get(ISheetDrawingService);
106
- const { op, unitId, subUnitId, type, objects } = params;
703
+ const { unitId, subUnitId, type, objects } = params;
704
+ if (params.reference !== void 0) {
705
+ const { legacyPositionDrawingIds } = params.reference;
706
+ if (legacyPositionDrawingIds !== void 0 && (!Array.isArray(legacyPositionDrawingIds) || legacyPositionDrawingIds.some((id) => typeof id !== "string"))) throw new Error("Invalid drawing reference change.");
707
+ transformSheetDrawingReference({
708
+ row: 0,
709
+ column: 0,
710
+ rowOffset: 0,
711
+ columnOffset: 0
712
+ }, params.reference);
713
+ }
714
+ if (params.recalculate !== void 0 && typeof params.recalculate !== "boolean") throw new Error("Invalid drawing reference change.");
715
+ const replay = (options === null || options === void 0 ? void 0 : options.fromChangeset) === true && options.fromCollab !== true;
716
+ if (!replay) assertCurrentSheetDrawingEdit(params);
717
+ const op = replay ? normalizeHistoricalSheetDrawingEdit(params.op, unitId, subUnitId, (drawingId) => sheetDrawingService.getDrawingByParam({
718
+ unitId,
719
+ subUnitId,
720
+ drawingId
721
+ }) ?? void 0, () => {
722
+ var _accessor$get2;
723
+ return (_accessor$get2 = accessor.get(SheetSkeletonService, Quantity.OPTIONAL)) === null || _accessor$get2 === void 0 ? void 0 : _accessor$get2.ensureSkeleton(unitId, subUnitId);
724
+ }) : params.op;
107
725
  drawingManagerService.applyJson1(unitId, subUnitId, op);
108
726
  sheetDrawingService.applyJson1(unitId, subUnitId, op);
727
+ const importedOrientation = type === 0 && objects.some((object) => {
728
+ const drawing = sheetDrawingService.getDrawingByParam(object);
729
+ return drawing && needsPlacementHydration(drawing);
730
+ });
731
+ const received = Boolean((options === null || options === void 0 ? void 0 : options.fromCollab) || replay || params.reference || params.recalculate);
732
+ if (received || importedOrientation) {
733
+ var _params$reference;
734
+ refreshReceivedDrawings(accessor, params, !received, ((_params$reference = params.reference) === null || _params$reference === void 0 ? void 0 : _params$reference.legacyPositionDrawingIds) ?? []);
735
+ }
109
736
  switch (type) {
110
737
  case 0:
111
738
  drawingManagerService.addNotification(objects);
@@ -159,11 +786,29 @@ const InsertSheetDrawingCommand = {
159
786
  const undoRedoService = accessor.get(IUndoRedoService);
160
787
  const sheetDrawingService = accessor.get(ISheetDrawingService);
161
788
  const sheetInterceptorService = accessor.get(SheetInterceptorService);
162
- const drawings = params.drawings;
789
+ const drawings = params.drawings.map((drawing) => {
790
+ const transform = getSheetDrawingTransformWithOrientation(drawing);
791
+ return [
792
+ "angle",
793
+ "flipX",
794
+ "flipY",
795
+ "skewX",
796
+ "skewY"
797
+ ].some((key) => {
798
+ var _drawing$transform;
799
+ return transform[key] !== ((_drawing$transform = drawing.transform) === null || _drawing$transform === void 0 ? void 0 : _drawing$transform[key]);
800
+ }) ? {
801
+ ...drawing,
802
+ transform
803
+ } : drawing;
804
+ });
163
805
  const { unitId, subUnitId, undo, redo, objects } = sheetDrawingService.getBatchAddOp(drawings);
164
806
  const intercepted = sheetInterceptorService.onCommandExecute({
165
807
  id: InsertSheetDrawingCommand.id,
166
- params
808
+ params: {
809
+ ...params,
810
+ drawings
811
+ }
167
812
  });
168
813
  const redoMutations = [
169
814
  ...intercepted.preRedos ?? [],
@@ -307,361 +952,68 @@ const RemoveSheetDrawingCommand = {
307
952
  });
308
953
  return true;
309
954
  }
310
- return false;
311
- }
312
- };
313
-
314
- // src/commands/commands/set-drawing-arrange.command.ts
315
- const SetDrawingArrangeCommand = {
316
- id: "sheet.command.set-drawing-arrange",
317
- type: CommandType.COMMAND,
318
- handler: (accessor, params) => {
319
- const commandService = accessor.get(ICommandService);
320
- const undoRedoService = accessor.get(IUndoRedoService);
321
- if (!params) return false;
322
- const sheetDrawingService = accessor.get(ISheetDrawingService);
323
- const { unitId, subUnitId, drawingIds } = params;
324
- const drawingOrderMapParam = {
325
- unitId,
326
- subUnitId,
327
- drawingIds
328
- };
329
- let jsonOp;
330
- if (params.zOrder !== void 0) jsonOp = sheetDrawingService.getDrawingOrderOp(drawingOrderMapParam, params.zOrder);
331
- else if (params.arrangeType === ArrangeTypeEnum.forward) jsonOp = sheetDrawingService.getForwardDrawingsOp(drawingOrderMapParam);
332
- else if (params.arrangeType === ArrangeTypeEnum.backward) jsonOp = sheetDrawingService.getBackwardDrawingOp(drawingOrderMapParam);
333
- else if (params.arrangeType === ArrangeTypeEnum.front) jsonOp = sheetDrawingService.getFrontDrawingsOp(drawingOrderMapParam);
334
- else if (params.arrangeType === ArrangeTypeEnum.back) jsonOp = sheetDrawingService.getBackDrawingsOp(drawingOrderMapParam);
335
- if (jsonOp == null) return false;
336
- const { objects, redo, undo } = jsonOp;
337
- if (commandService.syncExecuteCommand(SetDrawingApplyMutation.id, {
338
- op: redo,
339
- unitId,
340
- subUnitId,
341
- objects,
342
- type: 3
343
- })) {
344
- undoRedoService.pushUndoRedo({
345
- unitID: unitId,
346
- undoMutations: [{
347
- id: SetDrawingApplyMutation.id,
348
- params: {
349
- op: undo,
350
- unitId,
351
- subUnitId,
352
- objects,
353
- type: 3
354
- }
355
- }],
356
- redoMutations: [{
357
- id: SetDrawingApplyMutation.id,
358
- params: {
359
- op: redo,
360
- unitId,
361
- subUnitId,
362
- objects,
363
- type: 3
364
- }
365
- }]
366
- });
367
- return true;
368
- }
369
- return false;
370
- }
371
- };
372
-
373
- // src/services/sheet-drawing-placement.ts
374
- const PLACEMENT_ERROR = {
375
- CELL_INVALID: "SHEET_DRAWING_PLACEMENT_CELL_INVALID",
376
- EXTENT_INVALID: "SHEET_DRAWING_PLACEMENT_EXTENT_INVALID",
377
- KIND_INVALID: "SHEET_DRAWING_PLACEMENT_KIND_INVALID",
378
- POSITION_INVALID: "SHEET_DRAWING_PLACEMENT_POSITION_INVALID"
379
- };
380
- function getSheetDrawingPlacement(drawing) {
381
- var _drawing$transform5, _drawing$transform6;
382
- const anchorType = drawing.anchorType ?? "0";
383
- if (anchorType === "2") {
384
- var _drawing$transform, _drawing$transform2, _drawing$transform3, _drawing$transform4;
385
- return {
386
- kind: "2",
387
- left: ((_drawing$transform = drawing.transform) === null || _drawing$transform === void 0 ? void 0 : _drawing$transform.left) ?? 0,
388
- top: ((_drawing$transform2 = drawing.transform) === null || _drawing$transform2 === void 0 ? void 0 : _drawing$transform2.top) ?? 0,
389
- width: ((_drawing$transform3 = drawing.transform) === null || _drawing$transform3 === void 0 ? void 0 : _drawing$transform3.width) ?? 0,
390
- height: ((_drawing$transform4 = drawing.transform) === null || _drawing$transform4 === void 0 ? void 0 : _drawing$transform4.height) ?? 0
391
- };
392
- }
393
- if (anchorType === "1") return {
394
- kind: "1",
395
- from: { ...drawing.sheetTransform.from },
396
- to: { ...drawing.sheetTransform.to }
397
- };
398
- return {
399
- kind: "0",
400
- from: { ...drawing.sheetTransform.from },
401
- width: ((_drawing$transform5 = drawing.transform) === null || _drawing$transform5 === void 0 ? void 0 : _drawing$transform5.width) ?? 0,
402
- height: ((_drawing$transform6 = drawing.transform) === null || _drawing$transform6 === void 0 ? void 0 : _drawing$transform6.height) ?? 0
403
- };
404
- }
405
- function applySheetDrawingPlacement(drawing, input, skeleton) {
406
- return resolveSheetDrawingPlacement(drawing, normalizePlacement(input, skeleton, requiresDrawingArea(drawing)), skeleton);
407
- }
408
- /** Place a batch at the logical start corner of a Chart Sheet, preserving its relative geometry. */
409
- function transformDrawingsToChartSheet(drawings, chartSheetBounds, rightToLeft) {
410
- if (validateBounds(chartSheetBounds, true)) return null;
411
- if (!drawings.length) return [];
412
- const bounds = [];
413
- for (const drawing of drawings) {
414
- const state = drawing.transform;
415
- if (!state || validateBounds(state, requiresDrawingArea(drawing)) || [
416
- state.angle,
417
- state.skewX,
418
- state.skewY,
419
- state.scaleX,
420
- state.scaleY
421
- ].some((value) => value !== void 0 && !Number.isFinite(value))) return null;
422
- const { width = 0, height = 0, angle = 0 } = state;
423
- const matrix = Transform.create().composeMatrix(state);
424
- if (angle) matrix.rotate(-angle).translate(width / 2, height / 2).rotate(angle).translate(-width / 2, -height / 2);
425
- const box = matrix.makeBoundingBoxFromPoints([
426
- new Vector2(0, 0),
427
- new Vector2(width, 0),
428
- new Vector2(width, height),
429
- new Vector2(0, height)
430
- ]);
431
- bounds.push({
432
- left: box.left,
433
- top: box.top,
434
- width: box.width,
435
- height: box.height
436
- });
437
- }
438
- const group = getGroupState(0, 0, bounds);
439
- const scale = Math.min(1, group.width ? chartSheetBounds.width / group.width : 1, group.height ? chartSheetBounds.height / group.height : 1);
440
- const left = rightToLeft ? chartSheetBounds.left + chartSheetBounds.width - group.width * scale : chartSheetBounds.left;
441
- return drawings.map((drawing) => applySheetDrawingPlacement(drawing, {
442
- kind: "2",
443
- left: left + (drawing.transform.left - group.left) * scale,
444
- top: chartSheetBounds.top + (drawing.transform.top - group.top) * scale,
445
- width: drawing.transform.width * scale,
446
- height: drawing.transform.height * scale
447
- }));
448
- }
449
- /** Refresh layout-derived geometry without changing the drawing's anchor semantics. */
450
- function refreshSheetDrawingPlacement(drawing, skeleton) {
451
- const result = tryRefreshSheetDrawingPlacement(drawing, skeleton);
452
- if (!result.ok) throw createPlacementError(result);
453
- return result.drawing;
454
- }
455
- /** Validate persisted markers before any caller reads them to select a refresh range. */
456
- function validateSheetDrawingPlacement(drawing) {
457
- var _drawing$sheetTransfo, _drawing$sheetTransfo2;
458
- if (!drawing || typeof drawing !== "object") return {
459
- ok: false,
460
- reason: PLACEMENT_ERROR.KIND_INVALID
461
- };
462
- const anchorType = drawing.anchorType ?? "0";
463
- if (anchorType === "2") return;
464
- if (anchorType !== "0" && anchorType !== "1") return {
465
- ok: false,
466
- reason: PLACEMENT_ERROR.KIND_INVALID
467
- };
468
- const markerFailure = validateCellPosition((_drawing$sheetTransfo = drawing.sheetTransform) === null || _drawing$sheetTransfo === void 0 ? void 0 : _drawing$sheetTransfo.from) ?? validateCellPosition((_drawing$sheetTransfo2 = drawing.sheetTransform) === null || _drawing$sheetTransfo2 === void 0 ? void 0 : _drawing$sheetTransfo2.to);
469
- if (markerFailure) return markerFailure;
470
- return validatePlacement(getSheetDrawingPlacement(drawing), requiresDrawingArea(drawing));
471
- }
472
- /** Expected snapshot errors are results; unexpected calculation failures are caught by the task owner. */
473
- function tryRefreshSheetDrawingPlacement(drawing, skeleton) {
474
- var _resolved$transform, _resolved$transform2;
475
- const failure = validateSheetDrawingPlacement(drawing);
476
- if (failure) return failure;
477
- if (drawing.anchorType === "2") return {
478
- ok: true,
479
- drawing
480
- };
481
- const resolved = resolveSheetDrawingPlacement(drawing, getSheetDrawingPlacement(drawing), skeleton);
482
- const extentFailure = validateExtent(((_resolved$transform = resolved.transform) === null || _resolved$transform === void 0 ? void 0 : _resolved$transform.width) ?? 0, ((_resolved$transform2 = resolved.transform) === null || _resolved$transform2 === void 0 ? void 0 : _resolved$transform2.height) ?? 0, requiresDrawingArea(drawing), true);
483
- if (extentFailure) return extentFailure;
484
- return {
485
- ok: true,
486
- drawing: {
487
- ...drawing,
488
- sheetTransform: resolved.sheetTransform,
489
- transform: resolved.transform,
490
- axisAlignSheetTransform: resolved.axisAlignSheetTransform
491
- }
492
- };
493
- }
494
- function requiresDrawingArea(drawing) {
495
- return drawing.drawingType === DrawingTypeEnum.DRAWING_IMAGE || drawing.drawingType === DrawingTypeEnum.DRAWING_DOM;
496
- }
497
- function resolveSheetDrawingPlacement(drawing, placement, skeleton) {
498
- if (placement.kind === "2") {
499
- const transform = withExistingTransform(drawing.transform, placement);
500
- const sheetTransform = absoluteSheetTransform(placement, drawing.sheetTransform);
501
- return {
502
- ...drawing,
503
- anchorType: "2",
504
- transform,
505
- sheetTransform,
506
- axisAlignSheetTransform: sheetTransform
507
- };
508
- }
509
- if (!skeleton) throw new Error("SHEET_DRAWING_PLACEMENT_SKELETON_REQUIRED");
510
- if (placement.kind === "0") {
511
- const converted = convertPositionCellToSheetOverGrid(drawing.unitId, drawing.subUnitId, getVisibleCellPosition(placement.from, skeleton), placement.width, placement.height, skeleton);
512
- const sheetTransform = withExistingSheetTransform(drawing.sheetTransform, {
513
- from: placement.from,
514
- to: converted.sheetTransform.to
515
- });
516
- const transform = withExistingTransform(drawing.transform, converted.transform);
517
- return {
518
- ...drawing,
519
- anchorType: "0",
520
- sheetTransform,
521
- transform,
522
- axisAlignSheetTransform: withExistingSheetTransform(drawing.axisAlignSheetTransform, transformToAxisAlignPosition(transform, skeleton))
523
- };
524
- }
525
- const sheetTransform = withExistingSheetTransform(drawing.sheetTransform, {
526
- from: placement.from,
527
- to: placement.to
528
- });
529
- const bounds = convertPositionSheetOverGridToAbsolute(drawing.unitId, drawing.subUnitId, {
530
- from: getVisibleCellPosition(placement.from, skeleton),
531
- to: getVisibleCellPosition(placement.to, skeleton)
532
- }, skeleton);
533
- const transform = withExistingTransform(drawing.transform, bounds);
534
- return {
535
- ...drawing,
536
- anchorType: "1",
537
- sheetTransform,
538
- transform,
539
- axisAlignSheetTransform: withExistingSheetTransform(drawing.axisAlignSheetTransform, transformToAxisAlignPosition(transform, skeleton))
540
- };
541
- }
542
- function getVisibleCellPosition(position, skeleton) {
543
- const cell = skeleton.getNoMergeCellWithCoordByIndex(position.row, position.column);
544
- return {
545
- ...position,
546
- columnOffset: cell.startX === cell.endX ? 0 : position.columnOffset,
547
- rowOffset: cell.startY === cell.endY ? 0 : position.rowOffset
548
- };
549
- }
550
- /**
551
- * Normalize exact markers or model-space bounds to the authoritative
552
- * Position, Both, or None Placement.
553
- */
554
- function normalizeSheetDrawingPlacement(input, skeleton) {
555
- return normalizePlacement(input, skeleton, false);
556
- }
557
- function normalizePlacement(input, skeleton, requiresArea) {
558
- if (!("bounds" in input)) {
559
- assertValidPlacement(validatePlacement(input, requiresArea));
560
- if (input.kind === "1" && skeleton) assertValidPlacement(validateBounds(convertPositionSheetOverGridToAbsolute(skeleton.worksheet.getUnitId(), skeleton.worksheet.getSheetId(), {
561
- from: input.from,
562
- to: input.to
563
- }, skeleton), requiresArea));
564
- return input;
565
- }
566
- assertValidPlacement(validateBounds(input.bounds, requiresArea));
567
- if (input.kind === "2") return {
568
- kind: "2",
569
- ...input.bounds
570
- };
571
- if (!skeleton) throw new Error("SHEET_DRAWING_PLACEMENT_SKELETON_REQUIRED");
572
- const sheetTransform = transformToDrawingPosition(input.bounds, skeleton);
573
- if (input.kind === "0") return {
574
- kind: "0",
575
- from: sheetTransform.from,
576
- width: input.bounds.width,
577
- height: input.bounds.height
578
- };
579
- if (input.kind === "1") return {
580
- kind: "1",
581
- from: sheetTransform.from,
582
- to: sheetTransform.to
583
- };
584
- throw new Error(PLACEMENT_ERROR.KIND_INVALID);
585
- }
586
- function withExistingSheetTransform(current, placement) {
587
- return {
588
- ...current,
589
- from: { ...placement.from },
590
- to: { ...placement.to }
591
- };
592
- }
593
- function withExistingTransform(current, bounds) {
594
- return {
595
- ...current,
596
- left: bounds.left,
597
- top: bounds.top,
598
- width: bounds.width,
599
- height: bounds.height
600
- };
601
- }
602
- function absoluteSheetTransform(placement, current) {
603
- return {
604
- ...current,
605
- from: {
606
- column: 0,
607
- columnOffset: placement.left,
608
- row: 0,
609
- rowOffset: placement.top
610
- },
611
- to: {
612
- column: 0,
613
- columnOffset: placement.left + placement.width,
614
- row: 0,
615
- rowOffset: placement.top + placement.height
616
- }
617
- };
618
- }
619
- function validatePlacement(placement, requiresArea) {
620
- if (placement.kind === "0") return validateCellPosition(placement.from) ?? validateExtent(placement.width, placement.height, requiresArea);
621
- if (placement.kind === "1") return validateCellPosition(placement.from) ?? validateCellPosition(placement.to);
622
- if (placement.kind === "2") {
623
- if (!Number.isFinite(placement.left) || !Number.isFinite(placement.top)) return {
624
- ok: false,
625
- reason: PLACEMENT_ERROR.POSITION_INVALID
626
- };
627
- return validateExtent(placement.width, placement.height, requiresArea);
955
+ return false;
628
956
  }
629
- return {
630
- ok: false,
631
- reason: PLACEMENT_ERROR.KIND_INVALID
632
- };
633
- }
634
- function validateBounds(bounds, requiresArea) {
635
- if (!bounds || !Number.isFinite(bounds.left) || !Number.isFinite(bounds.top)) return {
636
- ok: false,
637
- reason: PLACEMENT_ERROR.POSITION_INVALID
638
- };
639
- return validateExtent(bounds.width, bounds.height, requiresArea);
640
- }
641
- function validateCellPosition(position) {
642
- if (!position || !Number.isInteger(position.row) || !Number.isInteger(position.column) || position.row < 0 || position.column < 0 || !Number.isFinite(position.rowOffset) || !Number.isFinite(position.columnOffset)) return {
643
- ok: false,
644
- reason: PLACEMENT_ERROR.CELL_INVALID
645
- };
646
- }
647
- function validateExtent(width, height, requiresArea, allowCollapsed = false) {
648
- const hasInvalidZeroExtent = !allowCollapsed && (requiresArea ? width === 0 || height === 0 : width === 0 && height === 0);
649
- if (!Number.isFinite(width) || !Number.isFinite(height) || width < 0 || height < 0 || hasInvalidZeroExtent) return {
650
- ok: false,
651
- reason: PLACEMENT_ERROR.EXTENT_INVALID,
652
- details: {
653
- width,
654
- height
957
+ };
958
+
959
+ // src/commands/commands/set-drawing-arrange.command.ts
960
+ const SetDrawingArrangeCommand = {
961
+ id: "sheet.command.set-drawing-arrange",
962
+ type: CommandType.COMMAND,
963
+ handler: (accessor, params) => {
964
+ const commandService = accessor.get(ICommandService);
965
+ const undoRedoService = accessor.get(IUndoRedoService);
966
+ if (!params) return false;
967
+ const sheetDrawingService = accessor.get(ISheetDrawingService);
968
+ const { unitId, subUnitId, drawingIds } = params;
969
+ const drawingOrderMapParam = {
970
+ unitId,
971
+ subUnitId,
972
+ drawingIds
973
+ };
974
+ let jsonOp;
975
+ if (params.zOrder !== void 0) jsonOp = sheetDrawingService.getDrawingOrderOp(drawingOrderMapParam, params.zOrder);
976
+ else if (params.arrangeType === ArrangeTypeEnum.forward) jsonOp = sheetDrawingService.getForwardDrawingsOp(drawingOrderMapParam);
977
+ else if (params.arrangeType === ArrangeTypeEnum.backward) jsonOp = sheetDrawingService.getBackwardDrawingOp(drawingOrderMapParam);
978
+ else if (params.arrangeType === ArrangeTypeEnum.front) jsonOp = sheetDrawingService.getFrontDrawingsOp(drawingOrderMapParam);
979
+ else if (params.arrangeType === ArrangeTypeEnum.back) jsonOp = sheetDrawingService.getBackDrawingsOp(drawingOrderMapParam);
980
+ if (jsonOp == null) return false;
981
+ const { objects, redo, undo } = jsonOp;
982
+ if (commandService.syncExecuteCommand(SetDrawingApplyMutation.id, {
983
+ op: redo,
984
+ unitId,
985
+ subUnitId,
986
+ objects,
987
+ type: 3
988
+ })) {
989
+ undoRedoService.pushUndoRedo({
990
+ unitID: unitId,
991
+ undoMutations: [{
992
+ id: SetDrawingApplyMutation.id,
993
+ params: {
994
+ op: undo,
995
+ unitId,
996
+ subUnitId,
997
+ objects,
998
+ type: 3
999
+ }
1000
+ }],
1001
+ redoMutations: [{
1002
+ id: SetDrawingApplyMutation.id,
1003
+ params: {
1004
+ op: redo,
1005
+ unitId,
1006
+ subUnitId,
1007
+ objects,
1008
+ type: 3
1009
+ }
1010
+ }]
1011
+ });
1012
+ return true;
655
1013
  }
656
- };
657
- }
658
- function assertValidPlacement(failure) {
659
- if (failure) throw createPlacementError(failure);
660
- }
661
- function createPlacementError(failure) {
662
- const error = failure.reason === PLACEMENT_ERROR.POSITION_INVALID ? new TypeError(failure.reason) : new Error(failure.reason);
663
- return Object.assign(error, failure.details);
664
- }
1014
+ return false;
1015
+ }
1016
+ };
665
1017
 
666
1018
  // src/commands/commands/set-sheet-drawing-placement.command.ts
667
1019
  const SetSheetDrawingPlacementCommand = {
@@ -690,7 +1042,29 @@ const SetSheetDrawingPlacementCommand = {
690
1042
  id: SetSheetDrawingPlacementCommand.id,
691
1043
  params
692
1044
  });
693
- const { unitId, subUnitId, undo, redo, objects } = drawingService.getBatchUpdateOp(updatedDrawings);
1045
+ const { unitId, subUnitId, objects, ...batch } = drawingService.getBatchUpdateOp(updatedDrawings);
1046
+ let { undo, redo } = batch;
1047
+ for (const drawing of updatedDrawings) {
1048
+ const original = drawingService.getDrawingByParam(drawing);
1049
+ if (original.anchorType === drawing.anchorType) continue;
1050
+ for (const endpoint of ["from", "to"]) for (const axis of ["row", "column"]) {
1051
+ var _original$axisAlignSh, _drawing$axisAlignShe;
1052
+ const before = (_original$axisAlignSh = original.axisAlignSheetTransform) === null || _original$axisAlignSh === void 0 || (_original$axisAlignSh = _original$axisAlignSh[endpoint]) === null || _original$axisAlignSh === void 0 ? void 0 : _original$axisAlignSh[axis];
1053
+ const after = (_drawing$axisAlignShe = drawing.axisAlignSheetTransform) === null || _drawing$axisAlignShe === void 0 || (_drawing$axisAlignShe = _drawing$axisAlignShe[endpoint]) === null || _drawing$axisAlignShe === void 0 ? void 0 : _drawing$axisAlignShe[axis];
1054
+ if (before === void 0 || after === void 0) continue;
1055
+ const path = [
1056
+ unitId,
1057
+ subUnitId,
1058
+ "data",
1059
+ drawing.drawingId,
1060
+ "axisAlignSheetTransform",
1061
+ endpoint,
1062
+ axis
1063
+ ];
1064
+ redo = JSON1.type.compose(redo, JSON1.replaceOp(path, after, after));
1065
+ undo = JSON1.type.compose(undo, JSON1.replaceOp(path, before, before));
1066
+ }
1067
+ }
694
1068
  const redoMutations = [
695
1069
  ...intercepted.preRedos ?? [],
696
1070
  {
@@ -798,7 +1172,45 @@ const SetSheetDrawingCommand = {
798
1172
  const sheetDrawingService = accessor.get(ISheetDrawingService);
799
1173
  const sheetInterceptorService = accessor.get(SheetInterceptorService);
800
1174
  const { drawings } = params;
801
- const normalizedDrawings = drawings.map((drawing) => normalizeNonRotatableAngleUpdate(drawing, sheetDrawingService));
1175
+ const normalizedDrawings = drawings.map((drawing) => {
1176
+ const normalized = normalizeNonRotatableAngleUpdate(drawing, sheetDrawingService);
1177
+ if (!normalized.unitId || !normalized.subUnitId || !normalized.drawingId) return normalized;
1178
+ const current = sheetDrawingService.getDrawingByParam({
1179
+ unitId: normalized.unitId,
1180
+ subUnitId: normalized.subUnitId,
1181
+ drawingId: normalized.drawingId
1182
+ });
1183
+ if (!current || !normalized.transform) return normalized;
1184
+ const transform = {
1185
+ ...getSheetDrawingTransformWithOrientation(current),
1186
+ ...normalized.transform
1187
+ };
1188
+ const patch = {
1189
+ ...normalized,
1190
+ transform
1191
+ };
1192
+ if (current.groupId || current.anchorType === "2") return patch;
1193
+ if (![
1194
+ "left",
1195
+ "top",
1196
+ "width",
1197
+ "height",
1198
+ "angle",
1199
+ "flipX",
1200
+ "flipY",
1201
+ "skewX",
1202
+ "skewY"
1203
+ ].some((key) => {
1204
+ var _normalized$transform, _current$transform;
1205
+ return ((_normalized$transform = normalized.transform) === null || _normalized$transform === void 0 ? void 0 : _normalized$transform[key]) !== void 0 && normalized.transform[key] !== ((_current$transform = current.transform) === null || _current$transform === void 0 ? void 0 : _current$transform[key]);
1206
+ })) return patch;
1207
+ const skeleton = accessor.get(SheetSkeletonService).ensureSkeleton(current.unitId, current.subUnitId);
1208
+ if (!skeleton) return normalized;
1209
+ return {
1210
+ ...patch,
1211
+ axisAlignSheetTransform: transformToAxisAlignPosition(transform, skeleton)
1212
+ };
1213
+ });
802
1214
  const normalizedParams = {
803
1215
  ...params,
804
1216
  drawings: normalizedDrawings
@@ -914,21 +1326,6 @@ const SetWorksheetBackgroundImageCommand = {
914
1326
  }
915
1327
  };
916
1328
 
917
- // \0@oxc-project+runtime@0.157.0/helpers/esm/decorateParam.js
918
- function __decorateParam(paramIndex, decorator) {
919
- return function(target, key) {
920
- decorator(target, key, paramIndex);
921
- };
922
- }
923
-
924
- // \0@oxc-project+runtime@0.157.0/helpers/esm/decorate.js
925
- function __decorate(decorators, target, key, desc) {
926
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
927
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
928
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
929
- return c > 3 && r && Object.defineProperty(target, key, r), r;
930
- }
931
-
932
1329
  // src/controllers/sheet-drawing.controller.ts
933
1330
  const SHEET_DRAWING_PLUGIN = "SHEET_DRAWING_PLUGIN";
934
1331
  function getDrawingsInOrder(drawingData, drawingOrder) {
@@ -947,7 +1344,7 @@ function getDrawingsInOrder(drawingData, drawingOrder) {
947
1344
  return drawings;
948
1345
  }
949
1346
  let SheetsDrawingLoadController = class SheetsDrawingLoadController extends Disposable {
950
- constructor(_sheetInterceptorService, _univerInstanceService, _commandService, _sheetDrawingService, _drawingManagerService, _resourceManagerService) {
1347
+ constructor(_sheetInterceptorService, _univerInstanceService, _commandService, _sheetDrawingService, _drawingManagerService, _resourceManagerService, _sheetSkeletonService) {
951
1348
  super();
952
1349
  this._sheetInterceptorService = _sheetInterceptorService;
953
1350
  this._univerInstanceService = _univerInstanceService;
@@ -955,6 +1352,7 @@ let SheetsDrawingLoadController = class SheetsDrawingLoadController extends Disp
955
1352
  this._sheetDrawingService = _sheetDrawingService;
956
1353
  this._drawingManagerService = _drawingManagerService;
957
1354
  this._resourceManagerService = _resourceManagerService;
1355
+ this._sheetSkeletonService = _sheetSkeletonService;
958
1356
  this._initCommands();
959
1357
  this._initSnapshot();
960
1358
  this._initSheetChange();
@@ -996,6 +1394,11 @@ let SheetsDrawingLoadController = class SheetsDrawingLoadController extends Disp
996
1394
  this._drawingManagerService.removeDrawingDataForUnit(unitId);
997
1395
  },
998
1396
  onLoad: (unitId, value) => {
1397
+ for (const [subUnitId, sheet] of Object.entries(value)) {
1398
+ const drawings = Object.entries(sheet.data);
1399
+ const skeleton = drawings.some(([, drawing]) => drawing.sheetTransform) ? this._sheetSkeletonService.ensureSkeleton(unitId, subUnitId) : void 0;
1400
+ for (const [drawingId, drawing] of drawings) sheet.data[drawingId] = normalizeSheetDrawing(drawing, skeleton);
1401
+ }
999
1402
  this._sheetDrawingService.registerDrawingData(unitId, value);
1000
1403
  this._drawingManagerService.registerDrawingData(unitId, value);
1001
1404
  }
@@ -1098,12 +1501,13 @@ SheetsDrawingLoadController = __decorate([
1098
1501
  __decorateParam(2, ICommandService),
1099
1502
  __decorateParam(3, ISheetDrawingService),
1100
1503
  __decorateParam(4, IDrawingManagerService),
1101
- __decorateParam(5, IResourceManagerService)
1504
+ __decorateParam(5, IResourceManagerService),
1505
+ __decorateParam(6, Inject(SheetSkeletonService))
1102
1506
  ], SheetsDrawingLoadController);
1103
1507
 
1104
1508
  // package.json
1105
1509
  var name = "@univerjs/sheets-drawing";
1106
- var version = "1.5.1";
1510
+ var version = "1.6.0";
1107
1511
 
1108
1512
  // src/config/config.ts
1109
1513
  /**
@@ -1125,7 +1529,7 @@ const SHEETS_DRAWING_PLUGIN_CONFIG_KEY = "sheets-drawing.config";
1125
1529
  const configSymbol = Symbol(SHEETS_DRAWING_PLUGIN_CONFIG_KEY);
1126
1530
  const defaultPluginConfig = {};
1127
1531
 
1128
- // \0@oxc-project+runtime@0.157.0/helpers/esm/typeof.js
1532
+ // \0@oxc-project+runtime@0.158.0/helpers/esm/typeof.js
1129
1533
  function _typeof(o) {
1130
1534
  "@babel/helpers - typeof";
1131
1535
  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
@@ -1135,7 +1539,7 @@ function _typeof(o) {
1135
1539
  }, _typeof(o);
1136
1540
  }
1137
1541
 
1138
- // \0@oxc-project+runtime@0.157.0/helpers/esm/toPrimitive.js
1542
+ // \0@oxc-project+runtime@0.158.0/helpers/esm/toPrimitive.js
1139
1543
  function toPrimitive(t, e) {
1140
1544
  if ("object" != _typeof(t) || !t) return t;
1141
1545
  var r;
@@ -1147,13 +1551,13 @@ function toPrimitive(t, e) {
1147
1551
  return ("string" === e ? String : Number)(t);
1148
1552
  }
1149
1553
 
1150
- // \0@oxc-project+runtime@0.157.0/helpers/esm/toPropertyKey.js
1554
+ // \0@oxc-project+runtime@0.158.0/helpers/esm/toPropertyKey.js
1151
1555
  function toPropertyKey(t) {
1152
1556
  var i = toPrimitive(t, "string");
1153
1557
  return "symbol" == _typeof(i) ? i : i + "";
1154
1558
  }
1155
1559
 
1156
- // \0@oxc-project+runtime@0.157.0/helpers/esm/defineProperty.js
1560
+ // \0@oxc-project+runtime@0.158.0/helpers/esm/defineProperty.js
1157
1561
  function _defineProperty(e, r, t) {
1158
1562
  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
1159
1563
  value: t,
@@ -1255,7 +1659,12 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1255
1659
  undos: []
1256
1660
  };
1257
1661
  this._currentCommand = commandInfo;
1258
- if (id === InsertRowCommand.id) return this._moveRowInterceptor(params, "insert");
1662
+ if ([
1663
+ InsertRowCommand.id,
1664
+ InsertColCommand.id,
1665
+ RemoveRowCommand.id,
1666
+ RemoveColCommand.id
1667
+ ].includes(id)) return this._moveRowOrColInterceptor(params, commandInfo);
1259
1668
  else if ([
1260
1669
  MoveColsCommand.id,
1261
1670
  MoveRowsCommand.id,
@@ -1280,10 +1689,7 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1280
1689
  const { unitId, subUnitId } = target;
1281
1690
  const { fromRange, toRange } = params;
1282
1691
  return this._moveRangeInterceptor(unitId, subUnitId, fromRange, toRange);
1283
- } else if (id === InsertColCommand.id) return this._moveColInterceptor(params, "insert");
1284
- else if (id === RemoveRowCommand.id) return this._moveRowInterceptor(params, "remove");
1285
- else if (id === RemoveColCommand.id) return this._moveColInterceptor(params, "remove");
1286
- else if (id === DeleteRangeMoveLeftCommand.id) {
1692
+ } else if (id === DeleteRangeMoveLeftCommand.id) {
1287
1693
  const { range } = params;
1288
1694
  return this._getRangeMoveUndo(range, 0);
1289
1695
  } else if (id === DeleteRangeMoveUpCommand.id) {
@@ -1297,7 +1703,7 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1297
1703
  return this._getRangeMoveUndo(range, 3);
1298
1704
  } else if (id === SetRowHiddenCommand.id || id === SetSpecificRowsVisibleCommand.id || id === SetColHiddenCommand.id || id === SetSpecificColsVisibleCommand.id || id === DeltaRowHeightCommand.id || id === DeltaColumnWidthCommand.id || id === SetRowHeightCommand.id || id === SetColWidthCommand.id) {
1299
1705
  const { unitId, subUnitId, ranges } = params;
1300
- return this._getDrawingUndoForRowAndColSize(unitId, subUnitId, ranges);
1706
+ return this._refreshDrawingForRowAndColSize(unitId, subUnitId, ranges);
1301
1707
  }
1302
1708
  return {
1303
1709
  redos: [],
@@ -1327,23 +1733,37 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1327
1733
  if (!patch.drawingId) return;
1328
1734
  const original = originals.get(patch.drawingId);
1329
1735
  if (!original) return;
1330
- plan.updates.set(patch.drawingId, {
1736
+ const candidate = {
1331
1737
  ...original,
1332
1738
  ...patch,
1333
1739
  transform: {
1334
1740
  ...original.transform,
1335
1741
  ...patch.transform
1336
1742
  },
1337
- sheetTransform: patch.sheetTransform ?? original.sheetTransform,
1338
- axisAlignSheetTransform: patch.axisAlignSheetTransform ?? original.axisAlignSheetTransform
1339
- });
1743
+ axisAlignSheetTransform: { ...patch.axisAlignSheetTransform ?? original.axisAlignSheetTransform }
1744
+ };
1745
+ for (const key of [
1746
+ "angle",
1747
+ "flipX",
1748
+ "flipY",
1749
+ "skewX",
1750
+ "skewY"
1751
+ ]) {
1752
+ var _original$transform;
1753
+ const value = (_original$transform = original.transform) === null || _original$transform === void 0 ? void 0 : _original$transform[key];
1754
+ if (value === void 0) delete candidate.transform[key];
1755
+ else Object.assign(candidate.transform, { [key]: value });
1756
+ }
1757
+ plan.updates.set(patch.drawingId, candidate);
1340
1758
  });
1341
1759
  const feature = this._transformPlanService.transform(plan);
1342
1760
  if (mode === "refresh") {
1343
1761
  const changed = [...plan.updates.values()].filter((drawing) => JSON.stringify(originals.get(drawing.drawingId)) !== JSON.stringify(drawing));
1344
1762
  if (changed.length) {
1345
- this._sheetDrawingService.refreshTransform(changed);
1346
- this._drawingManagerService.refreshTransform(changed);
1763
+ this._sheetDrawingService.refreshTransform(changed, false);
1764
+ this._drawingManagerService.refreshTransform(changed, false);
1765
+ this._sheetDrawingService.refreshTransformNotification(changed);
1766
+ this._drawingManagerService.refreshTransformNotification(changed);
1347
1767
  this._commandService.syncExecuteCommand(ClearSheetDrawingTransformerOperation.id, [unitId]);
1348
1768
  }
1349
1769
  return {
@@ -1365,8 +1785,40 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1365
1785
  const redos = [...feature.preRedos];
1366
1786
  const undos = [...feature.preUndos];
1367
1787
  const updates = [...plan.updates.values()].filter(({ drawingId }) => !plan.deletes.has(drawingId));
1368
- if (updates.length) {
1369
- const { undo, redo, objects } = this._sheetDrawingService.getBatchUpdateOp(updates);
1788
+ const reference = this._getStructuralReference(plan.command, plan.skeleton);
1789
+ if (updates.length || reference) {
1790
+ const batch = updates.length ? this._sheetDrawingService.getBatchUpdateOp(updates) : {
1791
+ undo: null,
1792
+ redo: null,
1793
+ objects: []
1794
+ };
1795
+ let { undo, redo } = batch;
1796
+ const { objects } = batch;
1797
+ if (reference) for (const drawing of updates) {
1798
+ const original = plan.originals.get(drawing.drawingId);
1799
+ for (const endpoint of ["from", "to"]) {
1800
+ var _original$axisAlignSh, _drawing$axisAlignShe;
1801
+ const before = original === null || original === void 0 || (_original$axisAlignSh = original.axisAlignSheetTransform) === null || _original$axisAlignSh === void 0 || (_original$axisAlignSh = _original$axisAlignSh[endpoint]) === null || _original$axisAlignSh === void 0 ? void 0 : _original$axisAlignSh[reference.axis];
1802
+ const after = (_drawing$axisAlignShe = drawing.axisAlignSheetTransform) === null || _drawing$axisAlignShe === void 0 || (_drawing$axisAlignShe = _drawing$axisAlignShe[endpoint]) === null || _drawing$axisAlignShe === void 0 ? void 0 : _drawing$axisAlignShe[reference.axis];
1803
+ if (before === void 0 || after === void 0) continue;
1804
+ const path = [
1805
+ unitId,
1806
+ subUnitId,
1807
+ "data",
1808
+ drawing.drawingId,
1809
+ "axisAlignSheetTransform",
1810
+ endpoint,
1811
+ reference.axis
1812
+ ];
1813
+ redo = JSON1.type.compose(redo, JSON1.replaceOp(path, after, after));
1814
+ undo = JSON1.type.compose(undo, JSON1.replaceOp(path, before, before));
1815
+ }
1816
+ }
1817
+ const inverseReference = reference ? {
1818
+ ...reference,
1819
+ action: reference.action === "insert" ? "remove" : "insert",
1820
+ limit: reference.limit + (reference.action === "insert" ? -1 : 1) * (reference.end - reference.start + 1)
1821
+ } : void 0;
1370
1822
  redos.push({
1371
1823
  id: SetDrawingApplyMutation.id,
1372
1824
  params: {
@@ -1374,7 +1826,8 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1374
1826
  subUnitId,
1375
1827
  op: redo,
1376
1828
  objects,
1377
- type: 2
1829
+ type: 2,
1830
+ ...reference ? { reference } : {}
1378
1831
  }
1379
1832
  });
1380
1833
  undos.push({
@@ -1384,7 +1837,8 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1384
1837
  subUnitId,
1385
1838
  op: undo,
1386
1839
  objects,
1387
- type: 2
1840
+ type: 2,
1841
+ ...inverseReference ? { reference: inverseReference } : {}
1388
1842
  }
1389
1843
  });
1390
1844
  }
@@ -1418,7 +1872,7 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1418
1872
  }
1419
1873
  redos.push(...feature.redos);
1420
1874
  undos.push(...feature.undos);
1421
- if (redos.length || undos.length) {
1875
+ if (updates.length || plan.deletes.size || feature.preRedos.length || feature.redos.length || feature.preUndos.length || feature.undos.length) {
1422
1876
  redos.push({
1423
1877
  id: ClearSheetDrawingTransformerOperation.id,
1424
1878
  params: [unitId]
@@ -1433,6 +1887,65 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1433
1887
  undos
1434
1888
  };
1435
1889
  }
1890
+ _getStructuralReference(command, skeleton) {
1891
+ const { id, params } = command;
1892
+ const row = id === InsertRowCommand.id || id === RemoveRowCommand.id;
1893
+ if (!row && id !== InsertColCommand.id && id !== RemoveColCommand.id) return;
1894
+ const { range } = params;
1895
+ const limit = row ? skeleton.worksheet.getRowCount() : skeleton.worksheet.getColumnCount();
1896
+ const cell = skeleton.getNoMergeCellWithCoordByIndex(row ? limit - 1 : 0, row ? 0 : limit - 1);
1897
+ return {
1898
+ axis: row ? "row" : "column",
1899
+ action: id === InsertRowCommand.id || id === InsertColCommand.id ? "insert" : "remove",
1900
+ start: row ? range.startRow : range.startColumn,
1901
+ end: row ? range.endRow : range.endColumn,
1902
+ limit,
1903
+ boundaryOffset: row ? cell.endY - cell.startY : cell.endX - cell.startX
1904
+ };
1905
+ }
1906
+ _transformDrawingReference(drawing, reference, skeleton) {
1907
+ if (validateSheetDrawingPlacement(drawing)) {
1908
+ this._logService.warn("[SheetDrawingTransformAffectedController]", "Skipping invalid structural drawing anchor", { drawingId: drawing.drawingId });
1909
+ return;
1910
+ }
1911
+ const { axis } = reference;
1912
+ const { axisAlignSheetTransform } = drawing;
1913
+ let candidate;
1914
+ if (drawing.anchorType === "1") {
1915
+ const anchor = axisAlignSheetTransform;
1916
+ if (anchor.to[axis] < reference.start) return;
1917
+ if (reference.action === "remove" && anchor.from[axis] >= reference.start && anchor.to[axis] <= reference.end) return null;
1918
+ const mapPosition = (position) => ({
1919
+ ...position,
1920
+ from: transformSheetDrawingReference(position.from, reference),
1921
+ to: transformSheetDrawingReference(position.to, reference)
1922
+ });
1923
+ candidate = {
1924
+ ...drawing,
1925
+ axisAlignSheetTransform: mapPosition(anchor)
1926
+ };
1927
+ } else {
1928
+ const field = getSheetDrawingPositionAnchorField(drawing);
1929
+ const { from, to } = drawing[field];
1930
+ if (Math.max(from[axis], (to === null || to === void 0 ? void 0 : to[axis]) ?? 1e400) < reference.start) return;
1931
+ candidate = {
1932
+ ...drawing,
1933
+ [field]: {
1934
+ ...drawing[field],
1935
+ from: transformSheetDrawingReference(from, reference)
1936
+ }
1937
+ };
1938
+ }
1939
+ const result = tryRefreshSheetDrawingPlacement(candidate, skeleton);
1940
+ if (result.ok) return {
1941
+ ...result.drawing,
1942
+ anchorType: drawing.anchorType
1943
+ };
1944
+ this._logService.warn("[SheetDrawingTransformAffectedController]", "Skipping invalid structural drawing placement", {
1945
+ drawingId: drawing.drawingId,
1946
+ result
1947
+ });
1948
+ }
1436
1949
  _getRangeMoveUndo(range, type) {
1437
1950
  const target = getSheetCommandTarget(this._univerInstanceService);
1438
1951
  if (!target) return {
@@ -1458,9 +1971,14 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1458
1971
  _getUpdateOrDeleteDrawings(range, type, drawing) {
1459
1972
  const updateDrawings = [];
1460
1973
  const deleteDrawings = [];
1461
- const { sheetTransform, anchorType = "0", transform, unitId, subUnitId, drawingId } = drawing;
1974
+ const { anchorType = "0", transform, unitId, subUnitId, drawingId } = drawing;
1462
1975
  const sheetSkeletonParam = this._sheetSkeletonService.getSkeletonParam(unitId, subUnitId);
1463
- if (anchorType === "2" || !sheetTransform || !transform || !sheetSkeletonParam) return {
1976
+ if (anchorType === "2" || !transform || !sheetSkeletonParam) return {
1977
+ updateDrawings,
1978
+ deleteDrawings
1979
+ };
1980
+ const sheetTransform = anchorType === "0" ? drawing[getSheetDrawingPositionAnchorField(drawing)] : getLegacySheetDrawingPosition(drawing, sheetSkeletonParam.skeleton);
1981
+ if (!(sheetTransform === null || sheetTransform === void 0 ? void 0 : sheetTransform.from) || !sheetTransform.to) return {
1464
1982
  updateDrawings,
1465
1983
  deleteDrawings
1466
1984
  };
@@ -1479,6 +1997,7 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1479
1997
  });
1480
1998
  else {
1481
1999
  const param = this._shrinkCol(startColumn, endColumn, {
2000
+ drawing,
1482
2001
  sheetSkeletonParam,
1483
2002
  sheetTransform,
1484
2003
  transform,
@@ -1496,6 +2015,7 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1496
2015
  });
1497
2016
  else {
1498
2017
  const param = this._shrinkRow(startRow, endRow, {
2018
+ drawing,
1499
2019
  sheetSkeletonParam,
1500
2020
  sheetTransform,
1501
2021
  transform,
@@ -1526,9 +2046,8 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1526
2046
  newTransform = param === null || param === void 0 ? void 0 : param.newTransform;
1527
2047
  axisAlignSheetTransform = (param === null || param === void 0 ? void 0 : param.axisAlignSheetTransform) ?? void 0;
1528
2048
  }
1529
- if (newSheetTransform && newTransform) updateDrawings.push({
2049
+ if (newSheetTransform && newTransform && axisAlignSheetTransform) updateDrawings.push({
1530
2050
  ...drawing,
1531
- sheetTransform: newSheetTransform,
1532
2051
  transform: newTransform,
1533
2052
  axisAlignSheetTransform
1534
2053
  });
@@ -1537,10 +2056,7 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1537
2056
  deleteDrawings
1538
2057
  };
1539
2058
  }
1540
- _createUndoAndRedoMutation(unitId, subUnitId, updateDrawings) {
1541
- return this._finalizePlan(unitId, subUnitId, updateDrawings);
1542
- }
1543
- _getDrawingUndoForRowAndColSize(unitId, subUnitId, ranges) {
2059
+ _refreshDrawingForRowAndColSize(unitId, subUnitId, ranges) {
1544
2060
  const sheetSkeletonParam = this._getCalculatedSkeletonParam(unitId, subUnitId);
1545
2061
  if (!sheetSkeletonParam) return {
1546
2062
  redos: [],
@@ -1551,7 +2067,7 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1551
2067
  const updateDrawings = [];
1552
2068
  Object.keys(drawingData).forEach((drawingId) => {
1553
2069
  const drawing = drawingData[drawingId];
1554
- if ((drawing === null || drawing === void 0 ? void 0 : drawing.anchorType) === "2") return;
2070
+ if ((drawing === null || drawing === void 0 ? void 0 : drawing.anchorType) === "2" || (drawing === null || drawing === void 0 ? void 0 : drawing.groupId)) return;
1555
2071
  const refreshed = this._tryRefreshDrawingPlacement(drawing, skeleton, this._currentCommand.id, ({ to }) => ranges.some(({ startRow, startColumn }) => to.row >= startRow && to.column >= startColumn));
1556
2072
  if (refreshed) updateDrawings.push(refreshed);
1557
2073
  });
@@ -1559,16 +2075,7 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1559
2075
  redos: [],
1560
2076
  undos: []
1561
2077
  };
1562
- return this._createUndoAndRedoMutation(unitId, subUnitId, updateDrawings);
1563
- }
1564
- _getUnitIdAndSubUnitId(params) {
1565
- const target = getSheetCommandTarget(this._univerInstanceService, params);
1566
- if (!target) return;
1567
- const { unitId, subUnitId } = target;
1568
- return {
1569
- unitId,
1570
- subUnitId
1571
- };
2078
+ return this._finalizePlan(unitId, subUnitId, updateDrawings, [], "refresh");
1572
2079
  }
1573
2080
  _moveRangeInterceptor(unitId, subUnitId, fromRange, toRange) {
1574
2081
  const sheetSkeletonParam = this._getCalculatedSkeletonParam(unitId, subUnitId);
@@ -1587,7 +2094,7 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1587
2094
  const containedDrawings = [];
1588
2095
  Object.keys(drawings).forEach((drawingId) => {
1589
2096
  const drawing = drawings[drawingId];
1590
- if (drawing.anchorType !== "1") return;
2097
+ if (drawing.anchorType !== "1" || drawing.groupId) return;
1591
2098
  const { transform } = drawing;
1592
2099
  if (!transform) return;
1593
2100
  const { left = 0, top = 0, width = 0, height = 0 } = transform;
@@ -1601,166 +2108,60 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1601
2108
  });
1602
2109
  const rowOffset = toRange.startRow - fromRange.startRow;
1603
2110
  const colOffset = toRange.startColumn - fromRange.startColumn;
1604
- const updateDrawings = containedDrawings.map((drawing) => {
1605
- const oldSheetTransform = drawing.sheetTransform;
1606
- const sheetTransform = {
1607
- to: {
1608
- ...oldSheetTransform.to,
1609
- row: oldSheetTransform.to.row + rowOffset,
1610
- column: oldSheetTransform.to.column + colOffset
1611
- },
1612
- from: {
1613
- ...oldSheetTransform.from,
1614
- row: oldSheetTransform.from.row + rowOffset,
1615
- column: oldSheetTransform.from.column + colOffset
1616
- }
1617
- };
1618
- const transform = drawingPositionToTransform(sheetTransform, sheetSkeletonParam);
1619
- return {
1620
- unitId,
1621
- subUnitId,
1622
- drawingId: drawing.drawingId,
1623
- transform,
1624
- sheetTransform
1625
- };
2111
+ const movePosition = (position) => ({
2112
+ ...position,
2113
+ from: {
2114
+ ...position.from,
2115
+ row: position.from.row + rowOffset,
2116
+ column: position.from.column + colOffset
2117
+ },
2118
+ to: {
2119
+ ...position.to,
2120
+ row: position.to.row + rowOffset,
2121
+ column: position.to.column + colOffset
2122
+ }
2123
+ });
2124
+ const updateDrawings = containedDrawings.flatMap((drawing) => {
2125
+ const result = tryRefreshSheetDrawingPlacement({
2126
+ ...drawing,
2127
+ axisAlignSheetTransform: movePosition(drawing.axisAlignSheetTransform)
2128
+ }, skeleton);
2129
+ if (result.ok) return [result.drawing];
2130
+ this._logSkippedDrawingRefresh(drawing, this._currentCommand.id, result);
2131
+ return [];
1626
2132
  });
1627
2133
  return this._finalizePlan(unitId, subUnitId, updateDrawings);
1628
2134
  }
1629
- _moveRowInterceptor(params, type) {
1630
- const target = this._getUnitIdAndSubUnitId(params);
2135
+ _moveRowOrColInterceptor(params, command) {
2136
+ const target = getSheetCommandTarget(this._univerInstanceService, params);
1631
2137
  if (!target) return {
1632
2138
  redos: [],
1633
2139
  undos: []
1634
2140
  };
1635
2141
  const { unitId, subUnitId } = target;
1636
- const sheetSkeletonParam = this._getCalculatedSkeletonParam(unitId, subUnitId);
1637
- if (!sheetSkeletonParam) return {
1638
- redos: [],
1639
- undos: []
1640
- };
1641
- const { range } = params;
1642
- const rowStartIndex = range.startRow;
1643
- const rowEndIndex = range.endRow;
1644
- const data = this._sheetDrawingService.getDrawingData(unitId, subUnitId);
1645
- const updateDrawings = [];
1646
- const deleteDrawings = [];
1647
- Object.keys(data).forEach((drawingId) => {
1648
- const { sheetTransform, transform, anchorType = "0" } = data[drawingId];
1649
- if (!sheetTransform || !transform) return;
1650
- let newSheetTransform;
1651
- let newTransform;
1652
- let axisAlignSheetTransform;
1653
- if (type === "insert") {
1654
- const param = this._expandRow(rowStartIndex, rowEndIndex, {
1655
- sheetSkeletonParam,
1656
- sheetTransform,
1657
- transform,
1658
- anchorType
1659
- });
1660
- newSheetTransform = param === null || param === void 0 ? void 0 : param.newSheetTransform;
1661
- newTransform = param === null || param === void 0 ? void 0 : param.newTransform;
1662
- axisAlignSheetTransform = (param === null || param === void 0 ? void 0 : param.axisAlignSheetTransform) ?? void 0;
1663
- } else {
1664
- const { from, to } = sheetTransform;
1665
- const { row: fromRow } = from;
1666
- const { row: toRow } = to;
1667
- if (anchorType === "1" && fromRow >= rowStartIndex && toRow <= rowEndIndex) deleteDrawings.push({
1668
- unitId,
1669
- subUnitId,
1670
- drawingId
1671
- });
1672
- else {
1673
- const param = this._shrinkRow(rowStartIndex, rowEndIndex, {
1674
- sheetSkeletonParam,
1675
- sheetTransform,
1676
- transform,
1677
- anchorType
1678
- });
1679
- newSheetTransform = param === null || param === void 0 ? void 0 : param.newSheetTransform;
1680
- newTransform = param === null || param === void 0 ? void 0 : param.newTransform;
1681
- axisAlignSheetTransform = (param === null || param === void 0 ? void 0 : param.axisAlignSheetTransform) ?? void 0;
1682
- }
1683
- }
1684
- if (!newSheetTransform || !newTransform) return;
1685
- const params = {
1686
- unitId,
1687
- subUnitId,
1688
- drawingId,
1689
- transform: newTransform,
1690
- sheetTransform: newSheetTransform,
1691
- axisAlignSheetTransform
1692
- };
1693
- updateDrawings.push(params);
1694
- });
1695
- return this._finalizePlan(unitId, subUnitId, updateDrawings, deleteDrawings);
1696
- }
1697
- _moveColInterceptor(params, type) {
1698
- const target = this._getUnitIdAndSubUnitId(params);
1699
- if (!target) return {
2142
+ const skeletonParam = this._getCalculatedSkeletonParam(unitId, subUnitId);
2143
+ if (!skeletonParam) return {
1700
2144
  redos: [],
1701
2145
  undos: []
1702
2146
  };
1703
- const { unitId, subUnitId } = target;
1704
- const sheetSkeletonParam = this._getCalculatedSkeletonParam(unitId, subUnitId);
1705
- if (!sheetSkeletonParam) return {
2147
+ const reference = this._getStructuralReference(command, skeletonParam.skeleton);
2148
+ if (!reference) return {
1706
2149
  redos: [],
1707
2150
  undos: []
1708
2151
  };
1709
- const { range } = params;
1710
- const colStartIndex = range.startColumn;
1711
- const colEndIndex = range.endColumn;
1712
- const data = this._sheetDrawingService.getDrawingData(unitId, subUnitId);
1713
- const updateDrawings = [];
1714
- const deleteDrawings = [];
1715
- Object.keys(data).forEach((drawingId) => {
1716
- const { sheetTransform, transform, anchorType = "0" } = data[drawingId];
1717
- if (!sheetTransform || !transform) return;
1718
- let newSheetTransform;
1719
- let newTransform;
1720
- let axisAlignSheetTransform;
1721
- if (type === "insert") {
1722
- const param = this._expandCol(colStartIndex, colEndIndex, {
1723
- sheetSkeletonParam,
1724
- sheetTransform,
1725
- transform,
1726
- anchorType
1727
- });
1728
- newSheetTransform = param === null || param === void 0 ? void 0 : param.newSheetTransform;
1729
- newTransform = param === null || param === void 0 ? void 0 : param.newTransform;
1730
- axisAlignSheetTransform = (param === null || param === void 0 ? void 0 : param.axisAlignSheetTransform) ?? void 0;
1731
- } else {
1732
- const { from, to } = sheetTransform;
1733
- const { column: fromColumn } = from;
1734
- const { column: toColumn } = to;
1735
- if (anchorType === "1" && fromColumn >= colStartIndex && toColumn <= colEndIndex) deleteDrawings.push({
1736
- unitId,
1737
- subUnitId,
1738
- drawingId
1739
- });
1740
- else {
1741
- const param = this._shrinkCol(colStartIndex, colEndIndex, {
1742
- sheetSkeletonParam,
1743
- sheetTransform,
1744
- transform,
1745
- anchorType
1746
- });
1747
- newSheetTransform = param === null || param === void 0 ? void 0 : param.newSheetTransform;
1748
- newTransform = param === null || param === void 0 ? void 0 : param.newTransform;
1749
- axisAlignSheetTransform = (param === null || param === void 0 ? void 0 : param.axisAlignSheetTransform) ?? void 0;
1750
- }
1751
- }
1752
- if (!newSheetTransform || !newTransform) return;
1753
- const params = {
2152
+ const updates = [];
2153
+ const deletes = [];
2154
+ for (const drawing of Object.values(this._sheetDrawingService.getDrawingData(unitId, subUnitId))) {
2155
+ if (drawing.anchorType === "2" || drawing.groupId || !drawing.transform) continue;
2156
+ const result = this._transformDrawingReference(drawing, reference, skeletonParam.skeleton);
2157
+ if (result === null) deletes.push({
1754
2158
  unitId,
1755
2159
  subUnitId,
1756
- drawingId,
1757
- transform: newTransform,
1758
- sheetTransform: newSheetTransform,
1759
- axisAlignSheetTransform
1760
- };
1761
- updateDrawings.push(params);
1762
- });
1763
- return this._finalizePlan(unitId, subUnitId, updateDrawings, deleteDrawings);
2160
+ drawingId: drawing.drawingId
2161
+ });
2162
+ else if (result) updates.push(result);
2163
+ }
2164
+ return this._finalizePlan(unitId, subUnitId, updates, deletes, "command", command);
1764
2165
  }
1765
2166
  _expandCol(colStartIndex, colEndIndex, options) {
1766
2167
  const { sheetSkeletonParam, sheetTransform, transform, anchorType = "0" } = options;
@@ -1834,7 +2235,7 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1834
2235
  column: toColumn - colCount
1835
2236
  }
1836
2237
  };
1837
- if (anchorType === "0") return this._resolveShiftedPositionDrawing(newSheetTransform, transform, sheetSkeletonParam);
2238
+ if (anchorType === "0") return this._resolveShiftedPositionDrawing(newSheetTransform.from, options.drawing, skeleton);
1838
2239
  newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
1839
2240
  } else if (anchorType === "1" && fromColumn >= colStartIndex && toColumn <= colEndIndex) return null;
1840
2241
  else if (fromColumn < colStartIndex && toColumn > colEndIndex) {
@@ -1868,13 +2269,10 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1868
2269
  newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
1869
2270
  axisAlignSheetTransform = transformToAxisAlignPosition(newTransform, skeleton);
1870
2271
  } else return this._resolveShiftedPositionDrawing({
1871
- ...sheetTransform,
1872
- from: {
1873
- ...from,
1874
- column: colStartIndex,
1875
- columnOffset: 0
1876
- }
1877
- }, transform, sheetSkeletonParam);
2272
+ ...from,
2273
+ column: colStartIndex,
2274
+ columnOffset: 0
2275
+ }, options.drawing, skeleton);
1878
2276
  } else if (toColumn >= colStartIndex && toColumn <= colEndIndex && anchorType === "1") {
1879
2277
  const boundaryColumn = Math.min(colStartIndex, skeleton.worksheet.getColumnCount() - 1);
1880
2278
  const boundaryCell = skeleton.getNoMergeCellWithCoordByIndex(from.row, boundaryColumn);
@@ -1962,7 +2360,7 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1962
2360
  row: toRow - rowCount
1963
2361
  }
1964
2362
  };
1965
- if (anchorType === "0") return this._resolveShiftedPositionDrawing(newSheetTransform, transform, sheetSkeletonParam);
2363
+ if (anchorType === "0") return this._resolveShiftedPositionDrawing(newSheetTransform.from, options.drawing, skeleton);
1966
2364
  newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
1967
2365
  } else if (anchorType === "1" && fromRow >= rowStartIndex && toRow <= rowEndIndex) return null;
1968
2366
  else if (fromRow < rowStartIndex && toRow > rowEndIndex) {
@@ -1996,13 +2394,10 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
1996
2394
  newTransform = drawingPositionToTransform(newSheetTransform, sheetSkeletonParam);
1997
2395
  axisAlignSheetTransform = transformToAxisAlignPosition(newTransform, skeleton);
1998
2396
  } else return this._resolveShiftedPositionDrawing({
1999
- ...sheetTransform,
2000
- from: {
2001
- ...from,
2002
- row: rowStartIndex,
2003
- rowOffset: 0
2004
- }
2005
- }, transform, sheetSkeletonParam);
2397
+ ...from,
2398
+ row: rowStartIndex,
2399
+ rowOffset: 0
2400
+ }, options.drawing, skeleton);
2006
2401
  } else if (toRow >= rowStartIndex && toRow <= rowEndIndex && anchorType === "1") {
2007
2402
  const boundaryRow = Math.min(rowStartIndex, skeleton.worksheet.getRowCount() - 1);
2008
2403
  const boundaryCell = skeleton.getNoMergeCellWithCoordByIndex(boundaryRow, from.column);
@@ -2018,16 +2413,22 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
2018
2413
  }
2019
2414
  return this._getStructuralDrawingResult(newSheetTransform, newTransform, axisAlignSheetTransform, skeleton);
2020
2415
  }
2021
- _resolveShiftedPositionDrawing(sheetTransform, transform, { unitId, sheetId, skeleton }) {
2022
- const converted = convertPositionCellToSheetOverGrid(unitId, sheetId, sheetTransform.from, transform.width ?? 0, transform.height ?? 0, skeleton);
2023
- const newTransform = {
2024
- ...transform,
2025
- ...converted.transform
2416
+ _resolveShiftedPositionDrawing(from, drawing, skeleton) {
2417
+ const field = getSheetDrawingPositionAnchorField(drawing);
2418
+ const result = tryRefreshSheetDrawingPlacement({
2419
+ ...drawing,
2420
+ [field]: {
2421
+ ...drawing[field],
2422
+ from
2423
+ }
2424
+ }, skeleton);
2425
+ if (!result.ok) return null;
2426
+ const { transform: newTransform, axisAlignSheetTransform } = result.drawing;
2427
+ return {
2428
+ newSheetTransform: getLegacySheetDrawingPosition(result.drawing, skeleton),
2429
+ newTransform,
2430
+ axisAlignSheetTransform
2026
2431
  };
2027
- return this._getStructuralDrawingResult({
2028
- ...sheetTransform,
2029
- ...transformToDrawingPosition(newTransform, skeleton)
2030
- }, newTransform, null, skeleton);
2031
2432
  }
2032
2433
  _getStructuralDrawingResult(newSheetTransform, newTransform, axisAlignSheetTransform, skeleton) {
2033
2434
  if (!newSheetTransform || !newTransform) return null;
@@ -2052,8 +2453,23 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
2052
2453
  this._logSkippedDrawingRefresh(drawing, commandId, failure);
2053
2454
  return;
2054
2455
  }
2055
- if (shouldRefresh && !shouldRefresh(drawing.sheetTransform)) return;
2056
- const result = tryRefreshSheetDrawingPlacement(drawing, skeleton);
2456
+ const oneCell = (drawing.anchorType ?? "0") === "0";
2457
+ const rebuilt = oneCell && validateSheetDrawingPlacement({
2458
+ ...drawing,
2459
+ anchorType: "1"
2460
+ }) ? tryRefreshSheetDrawingPlacement(drawing, skeleton) : void 0;
2461
+ if (rebuilt && !rebuilt.ok) {
2462
+ this._logSkippedDrawingRefresh(drawing, commandId, rebuilt);
2463
+ return;
2464
+ }
2465
+ const candidate = (rebuilt === null || rebuilt === void 0 ? void 0 : rebuilt.ok) ? rebuilt.drawing : drawing;
2466
+ const anchor = oneCell ? candidate[getSheetDrawingPositionAnchorField(candidate)] : candidate.axisAlignSheetTransform ?? candidate.sheetTransform;
2467
+ const { from } = anchor;
2468
+ if (shouldRefresh && !shouldRefresh({
2469
+ from,
2470
+ to: anchor.to ?? from
2471
+ })) return (rebuilt === null || rebuilt === void 0 ? void 0 : rebuilt.ok) ? rebuilt.drawing : void 0;
2472
+ const result = rebuilt ?? tryRefreshSheetDrawingPlacement(candidate, skeleton);
2057
2473
  if (result.ok) return result.drawing;
2058
2474
  this._logSkippedDrawingRefresh(drawing, commandId, result);
2059
2475
  } catch (error) {
@@ -2067,37 +2483,35 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
2067
2483
  drawingId: drawing === null || drawing === void 0 ? void 0 : drawing.drawingId,
2068
2484
  commandId,
2069
2485
  transform: drawing === null || drawing === void 0 ? void 0 : drawing.transform,
2070
- sheetTransform: drawing === null || drawing === void 0 ? void 0 : drawing.sheetTransform,
2486
+ axisAlignSheetTransform: drawing === null || drawing === void 0 ? void 0 : drawing.axisAlignSheetTransform,
2071
2487
  failure
2072
2488
  });
2073
2489
  }
2074
2490
  _sheetRefreshListener() {
2075
2491
  this.disposeWithMe(this._commandService.onCommandExecuted((command) => {
2076
2492
  if (!REFRESH_MUTATIONS.includes(command.id)) return;
2077
- queueMicrotask(() => {
2078
- if (this._disposed) return;
2079
- try {
2080
- const params = command.params;
2081
- const target = getSheetCommandTarget(this._univerInstanceService, params);
2082
- if (!target) return;
2083
- const { unitId, subUnitId, worksheet } = target;
2084
- let ranges = [];
2085
- if ("ranges" in params) ranges = params.ranges;
2086
- else if ("rowsAutoHeightInfo" in params) ranges = params.rowsAutoHeightInfo.map((info) => ({
2087
- startRow: info.row,
2088
- endRow: info.row,
2089
- startColumn: 0,
2090
- endColumn: worksheet.getColumnCount() - 1
2091
- }));
2092
- this._refreshDrawingTransform(command, unitId, subUnitId, ranges);
2093
- } catch (error) {
2094
- this._logService.error("[SheetDrawingTransformAffectedController]", "Drawing layout refresh failed", {
2095
- commandId: command.id,
2096
- params: command.params,
2097
- error
2098
- });
2099
- }
2100
- });
2493
+ if (this._disposed) return;
2494
+ try {
2495
+ const params = command.params;
2496
+ const target = getSheetCommandTarget(this._univerInstanceService, params);
2497
+ if (!target) return;
2498
+ const { unitId, subUnitId, worksheet } = target;
2499
+ let ranges = [];
2500
+ if ("ranges" in params) ranges = params.ranges;
2501
+ else if ("rowsAutoHeightInfo" in params) ranges = params.rowsAutoHeightInfo.map((info) => ({
2502
+ startRow: info.row,
2503
+ endRow: info.row,
2504
+ startColumn: 0,
2505
+ endColumn: worksheet.getColumnCount() - 1
2506
+ }));
2507
+ this._refreshDrawingTransform(command, unitId, subUnitId, ranges);
2508
+ } catch (error) {
2509
+ this._logService.error("[SheetDrawingTransformAffectedController]", "Drawing layout refresh failed", {
2510
+ commandId: command.id,
2511
+ params: command.params,
2512
+ error
2513
+ });
2514
+ }
2101
2515
  }));
2102
2516
  }
2103
2517
  _refreshDrawingTransform(command, unitId, subUnitId, ranges) {
@@ -2107,7 +2521,7 @@ let SheetDrawingTransformAffectedController = class SheetDrawingTransformAffecte
2107
2521
  const updateDrawings = [];
2108
2522
  Object.keys(drawingData).forEach((drawingId) => {
2109
2523
  const drawing = drawingData[drawingId];
2110
- if ((drawing === null || drawing === void 0 ? void 0 : drawing.anchorType) === "2") return;
2524
+ if ((drawing === null || drawing === void 0 ? void 0 : drawing.anchorType) === "2" || (drawing === null || drawing === void 0 ? void 0 : drawing.groupId)) return;
2111
2525
  const refreshed = this._tryRefreshDrawingPlacement(drawing, sheetSkeletonParam.skeleton, command.id, ({ from, to }) => {
2112
2526
  const { row: fromRow, column: fromColumn } = from;
2113
2527
  const { row: toRow, column: toColumn } = to;
@@ -2173,4 +2587,4 @@ UniverSheetsDrawingPlugin = __decorate([
2173
2587
  __decorateParam(2, IConfigService)
2174
2588
  ], UniverSheetsDrawingPlugin);
2175
2589
 
2176
- export { ClearSheetDrawingTransformerOperation, DrawingApplyType, ISheetDrawingService, InsertSheetDrawingCommand, RemoveSheetDrawingCommand, SHEET_DRAWING_PLUGIN, SetDrawingApplyMutation, SetDrawingArrangeCommand, SetSheetDrawingCommand, SetSheetDrawingPlacementCommand, SetWorksheetBackgroundImageCommand, SetWorksheetBackgroundImageMutation, SheetDrawingAnchorType, SheetDrawingService, SheetDrawingTransformPlanService, UniverSheetsDrawingPlugin, applySheetDrawingPlacement, drawingPositionToTransform, getSheetDrawingPlacement, isKnownSheetNonRotatableDrawingType, normalizeSheetDrawingPlacement, refreshSheetDrawingPlacement, resolveSheetDrawingRotateEnabled, transformDrawingsToChartSheet, transformToAxisAlignPosition, transformToDrawingPosition };
2590
+ export { ClearSheetDrawingTransformerOperation, DrawingApplyType, ISheetDrawingService, InsertSheetDrawingCommand, RemoveSheetDrawingCommand, SHEET_DRAWING_PLUGIN, SetDrawingApplyMutation, SetDrawingArrangeCommand, SetSheetDrawingCommand, SetSheetDrawingPlacementCommand, SetWorksheetBackgroundImageCommand, SetWorksheetBackgroundImageMutation, SheetDrawingAnchorType, SheetDrawingService, SheetDrawingTransformPlanService, UniverSheetsDrawingPlugin, applySheetDrawingPlacement, assertCurrentSheetDrawingEdit, drawingPositionToTransform, getLegacySheetDrawingPosition, getSheetDrawingPlacement, isKnownSheetNonRotatableDrawingType, normalizeSheetDrawingPlacement, refreshSheetDrawingPlacement, resolveSheetDrawingRotateEnabled, transformDrawingsToChartSheet, transformSheetDrawingReference, transformToAxisAlignPosition, transformToDrawingPosition };