@sequent-org/moodboard 1.2.118 → 1.3.0

package/src/core/flows/LayerAndViewportFlow.js

@@ -0,0 +1,283 @@
+import { Events } from '../events/Events.js';
+import {
+    ReorderZCommand,
+    GroupReorderZCommand,
+    GroupMoveCommand,
+    MoveObjectCommand
+} from '../commands/index.js';
+
+export function setupLayerAndViewportFlow(core) {
+    const applyZOrderFromState = () => {
+        const arr = core.state.state.objects || [];
+        core.pixi.app.stage.sortableChildren = true;
+        for (let i = 0; i < arr.length; i++) {
+            const id = arr[i]?.id;
+            const pixi = id ? core.pixi.objects.get(id) : null;
+            if (pixi) pixi.zIndex = i;
+        }
+    };
+
+    core.eventBus.on(Events.UI.LayerBringToFront, ({ objectId }) => {
+        const arr = core.state.state.objects || [];
+        const from = arr.findIndex(o => o.id === objectId);
+        if (from === -1) return;
+        const to = arr.length - 1;
+        if (from === to) return;
+        const cmd = new ReorderZCommand(core, objectId, from, to);
+        cmd.setEventBus(core.eventBus);
+        core.history.executeCommand(cmd);
+    });
+    core.eventBus.on(Events.UI.LayerBringForward, ({ objectId }) => {
+        const arr = core.state.state.objects || [];
+        const from = arr.findIndex(o => o.id === objectId);
+        if (from === -1) return;
+        const to = Math.min(from + 1, arr.length - 1);
+        if (from === to) return;
+        const cmd = new ReorderZCommand(core, objectId, from, to);
+        cmd.setEventBus(core.eventBus);
+        core.history.executeCommand(cmd);
+    });
+    core.eventBus.on(Events.UI.LayerSendBackward, ({ objectId }) => {
+        const arr = core.state.state.objects || [];
+        const from = arr.findIndex(o => o.id === objectId);
+        if (from === -1) return;
+        const to = Math.max(from - 1, 0);
+        if (from === to) return;
+        const cmd = new ReorderZCommand(core, objectId, from, to);
+        cmd.setEventBus(core.eventBus);
+        core.history.executeCommand(cmd);
+    });
+    core.eventBus.on(Events.UI.LayerSendToBack, ({ objectId }) => {
+        const arr = core.state.state.objects || [];
+        const from = arr.findIndex(o => o.id === objectId);
+        if (from === -1) return;
+        const to = 0;
+        if (from === to) return;
+        const cmd = new ReorderZCommand(core, objectId, from, to);
+        cmd.setEventBus(core.eventBus);
+        core.history.executeCommand(cmd);
+    });
+
+    const getSelection = () => {
+        const ids = core.toolManager.getActiveTool()?.name === 'select'
+            ? Array.from(core.toolManager.getActiveTool().selectedObjects || [])
+            : [];
+        return ids;
+    };
+
+    core.eventBus.on(Events.UI.LayerGroupBringToFront, () => {
+        const ids = getSelection();
+        if (ids.length === 0) return;
+        const cmd = new GroupReorderZCommand(core, ids, 'front');
+        cmd.setEventBus(core.eventBus);
+        core.history.executeCommand(cmd);
+    });
+    core.eventBus.on(Events.UI.LayerGroupBringForward, () => {
+        const ids = getSelection();
+        if (ids.length === 0) return;
+        const cmd = new GroupReorderZCommand(core, ids, 'forward');
+        cmd.setEventBus(core.eventBus);
+        core.history.executeCommand(cmd);
+    });
+    core.eventBus.on(Events.UI.LayerGroupSendBackward, () => {
+        const ids = getSelection();
+        if (ids.length === 0) return;
+        const cmd = new GroupReorderZCommand(core, ids, 'backward');
+        cmd.setEventBus(core.eventBus);
+        core.history.executeCommand(cmd);
+    });
+    core.eventBus.on(Events.UI.LayerGroupSendToBack, () => {
+        const ids = getSelection();
+        if (ids.length === 0) return;
+        const cmd = new GroupReorderZCommand(core, ids, 'back');
+        cmd.setEventBus(core.eventBus);
+        core.history.executeCommand(cmd);
+    });
+
+    core.eventBus.on(Events.Tool.DragStart, (data) => {
+        const pixiObject = core.pixi.objects.get(data.object);
+        if (pixiObject) {
+            const halfW = (pixiObject.width || 0) / 2;
+            const halfH = (pixiObject.height || 0) / 2;
+            core.dragStartPosition = { x: pixiObject.x - halfW, y: pixiObject.y - halfH };
+        }
+    });
+
+    core.eventBus.on(Events.Tool.PanUpdate, ({ delta }) => {
+        if (core.pixi.worldLayer) {
+            core.pixi.worldLayer.x += delta.x;
+            core.pixi.worldLayer.y += delta.y;
+        }
+        if (core.pixi.gridLayer) {
+            core.pixi.gridLayer.x += delta.x;
+            core.pixi.gridLayer.y += delta.y;
+        }
+        if (!core.pixi.worldLayer) {
+            const stage = core.pixi.app.stage;
+            stage.x += delta.x;
+            stage.y += delta.y;
+        }
+        try {
+            const world = core.pixi.worldLayer || core.pixi.app.stage;
+            core.eventBus.emit(Events.Grid.BoardDataChanged, {
+                settings: { pan: { x: world.x || 0, y: world.y || 0 } }
+            });
+        } catch (_) {}
+        core.eventBus.emit(Events.Viewport.Changed);
+    });
+
+    core.eventBus.on(Events.UI.ZoomSelection, () => {
+        const selected = core.selectTool ? Array.from(core.selectTool.selectedObjects || []) : [];
+        if (!selected || selected.length === 0) return;
+        const objs = core.state.state.objects || [];
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        for (const o of objs) {
+            if (!selected.includes(o.id)) continue;
+            minX = Math.min(minX, o.position.x);
+            minY = Math.min(minY, o.position.y);
+            maxX = Math.max(maxX, o.position.x + (o.width || 0));
+            maxY = Math.max(maxY, o.position.y + (o.height || 0));
+        }
+        if (!isFinite(minX)) return;
+        const bboxW = Math.max(1, maxX - minX);
+        const bboxH = Math.max(1, maxY - minY);
+        const viewW = core.pixi.app.view.clientWidth;
+        const viewH = core.pixi.app.view.clientHeight;
+        const padding = 40;
+        const scaleX = (viewW - padding) / bboxW;
+        const scaleY = (viewH - padding) / bboxH;
+        const newScale = Math.max(0.02, Math.min(5, Math.min(scaleX, scaleY)));
+        const world = core.pixi.worldLayer || core.pixi.app.stage;
+        const worldCenterX = minX + bboxW / 2;
+        const worldCenterY = minY + bboxH / 2;
+        world.scale.set(newScale);
+        world.x = viewW / 2 - worldCenterX * newScale;
+        world.y = viewH / 2 - worldCenterY * newScale;
+        core.eventBus.emit(Events.UI.ZoomPercent, { percentage: Math.round(newScale * 100) });
+        core.eventBus.emit(Events.Viewport.Changed);
+    });
+
+    core.eventBus.on(Events.UI.MinimapGetData, (data) => {
+        const world = core.pixi.worldLayer || core.pixi.app.stage;
+        const view = core.pixi.app.view;
+        const scale = world?.scale?.x || 1;
+
+        const objects = (core.state.state.objects || []).map((o) => ({
+            id: o.id,
+            x: o.position?.x ?? 0,
+            y: o.position?.y ?? 0,
+            width: o.width ?? 0,
+            height: o.height ?? 0,
+            rotation: o.rotation ?? (o.transform?.rotation ?? 0)
+        }));
+
+        data.world = { x: world.x || 0, y: world.y || 0, scale };
+        data.view = { width: view.clientWidth, height: view.clientHeight };
+        data.objects = objects;
+    });
+
+    core.eventBus.on(Events.UI.MinimapCenterOn, ({ worldX, worldY }) => {
+        const world = core.pixi.worldLayer || core.pixi.app.stage;
+        const view = core.pixi.app.view;
+        const s = world?.scale?.x || 1;
+        world.x = view.clientWidth / 2 - worldX * s;
+        world.y = view.clientHeight / 2 - worldY * s;
+    });
+
+    core.eventBus.on(Events.Tool.GroupDragStart, (data) => {
+        core._groupDragStart = new Map();
+        for (const id of data.objects) {
+            const pixiObject = core.pixi.objects.get(id);
+            if (pixiObject) core._groupDragStart.set(id, { x: pixiObject.x, y: pixiObject.y });
+        }
+    });
+
+    core.eventBus.on(Events.Tool.GroupDragUpdate, (data) => {
+        const { dx, dy } = data.delta;
+        for (const id of data.objects) {
+            const pixiObject = core.pixi.objects.get(id);
+            if (!pixiObject) continue;
+            const startCenter = core._groupDragStart.get(id) || { x: pixiObject.x, y: pixiObject.y };
+            const newCenter = { x: startCenter.x + dx, y: startCenter.y + dy };
+            pixiObject.x = newCenter.x;
+            pixiObject.y = newCenter.y;
+            const obj = core.state.state.objects.find(o => o.id === id);
+            if (obj) {
+                const halfW = (pixiObject.width || 0) / 2;
+                const halfH = (pixiObject.height || 0) / 2;
+                obj.position.x = newCenter.x - halfW;
+                obj.position.y = newCenter.y - halfH;
+            }
+        }
+        core.state.markDirty();
+    });
+
+    core.eventBus.on(Events.Tool.GroupDragEnd, (data) => {
+        const moves = [];
+        for (const id of data.objects) {
+            const start = core._groupDragStart?.get(id);
+            const pixiObject = core.pixi.objects.get(id);
+            if (!start || !pixiObject) continue;
+            const finalPosition = { x: pixiObject.x, y: pixiObject.y };
+            if (start.x !== finalPosition.x || start.y !== finalPosition.y) {
+                moves.push({ id, from: start, to: finalPosition });
+            }
+        }
+        if (moves.length > 0) {
+            const cmd = new GroupMoveCommand(core, moves, false);
+            cmd.setEventBus(core.eventBus);
+            core.history.executeCommand(cmd);
+        }
+        core._groupDragStart = null;
+    });
+
+    core.eventBus.on(Events.Tool.DragUpdate, (data) => {
+        core.updateObjectPositionDirect(data.object, data.position);
+    });
+
+    core.eventBus.on(Events.Tool.DragEnd, (data) => {
+        if (core.dragStartPosition) {
+            const pixiObject = core.pixi.objects.get(data.object);
+            if (pixiObject) {
+                const objState = core.state.state.objects.find(o => o.id === data.object);
+                const finalPosition = objState && objState.position ? { x: objState.position.x, y: objState.position.y } : { x: 0, y: 0 };
+
+                if (core.dragStartPosition.x !== finalPosition.x ||
+                    core.dragStartPosition.y !== finalPosition.y) {
+                    const moved = core.state.state.objects.find(o => o.id === data.object);
+                    if (moved && moved.type === 'frame') {
+                        const attachments = core._getFrameChildren(moved.id);
+                        const moves = [];
+                        moves.push({ id: moved.id, from: core.dragStartPosition, to: finalPosition });
+                        const dx = finalPosition.x - core.dragStartPosition.x;
+                        const dy = finalPosition.y - core.dragStartPosition.y;
+                        for (const childId of attachments) {
+                            const child = core.state.state.objects.find(o => o.id === childId);
+                            if (!child) continue;
+                            const start = core._frameDragChildStart?.get(childId);
+                            const from = start ? { x: start.x, y: start.y } : { x: (child.position.x - dx), y: (child.position.y - dy) };
+                            const to = { x: child.position.x, y: child.position.y };
+                            moves.push({ id: childId, from, to });
+                        }
+                        const cmd = new GroupMoveCommand(core, moves, true);
+                        cmd.setEventBus(core.eventBus);
+                        core.history.executeCommand(cmd);
+                    } else {
+                        const command = new MoveObjectCommand(
+                            core,
+                            data.object,
+                            core.dragStartPosition,
+                            finalPosition
+                        );
+                        command.setEventBus(core.eventBus);
+                        core.history.executeCommand(command);
+                    }
+                }
+            }
+            core.dragStartPosition = null;
+        }
+    });
+}

package/src/core/flows/ObjectLifecycleFlow.js

@@ -0,0 +1,336 @@
+import { Events } from '../events/Events.js';
+import {
+    EditFileNameCommand,
+    GroupDeleteCommand,
+    UpdateContentCommand,
+    UpdateTextStyleCommand,
+    UpdateNoteStyleCommand,
+    UpdateFramePropertiesCommand,
+} from '../commands/index.js';
+
+const TEXT_STYLE_PROPS = ['fontFamily', 'fontSize', 'color', 'backgroundColor'];
+const TEXT_STYLE_DEFAULTS = {
+    fontFamily: 'Roboto, Arial, sans-serif',
+    fontSize: 18,
+    color: '#000000',
+    backgroundColor: 'transparent',
+};
+
+const NOTE_STYLE_PROPS = ['fontFamily', 'fontSize', 'textColor', 'backgroundColor'];
+const NOTE_STYLE_DEFAULTS = {
+    fontFamily: 'Caveat, Arial, cursive',
+    fontSize: 32,
+    textColor: 0x1a1a1a,
+    backgroundColor: 0xfff9c4,
+};
+
+/**
+ * Если updates.properties содержит ровно одно свойство стиля записки — создаёт UpdateNoteStyleCommand.
+ * @returns {boolean} true, если команда создана и применена
+ */
+function tryCreateNoteStyleCommand(core, object, objectId, updates) {
+    if (object.type !== 'note') return false;
+    if (!updates.properties || Object.keys(updates).length !== 1) return false;
+
+    const propKeys = Object.keys(updates.properties);
+    if (propKeys.length !== 1 || !NOTE_STYLE_PROPS.includes(propKeys[0])) return false;
+
+    const property = propKeys[0];
+    const newValue = updates.properties[property];
+
+    const oldValue = object.properties?.[property] ?? NOTE_STYLE_DEFAULTS[property];
+    if (oldValue === newValue) return false;
+
+    const command = new UpdateNoteStyleCommand(core, objectId, property, oldValue, newValue);
+    core.history.executeCommand(command);
+    return true;
+}
+
+/**
+ * Если updates содержит ровно одно свойство стиля текста — создаёт UpdateTextStyleCommand и выполняет её.
+ * @returns {boolean} true, если команда создана и применена (дальнейшая обработка не нужна)
+ */
+function tryCreateTextStyleCommand(core, object, objectId, updates) {
+    if (object.type !== 'text' && object.type !== 'simple-text') return false;
+
+    let property = null;
+    let newValue = null;
+
+    if (updates.properties?.fontFamily !== undefined && Object.keys(updates).length === 1) {
+        property = 'fontFamily';
+        newValue = updates.properties.fontFamily;
+    } else if (updates.fontSize !== undefined && !updates.properties && Object.keys(updates).length === 1) {
+        property = 'fontSize';
+        newValue = typeof updates.fontSize === 'string' ? parseInt(updates.fontSize, 10) : updates.fontSize;
+    } else if (updates.color !== undefined && !updates.properties && Object.keys(updates).length === 1) {
+        property = 'color';
+        newValue = updates.color;
+    } else if (updates.backgroundColor !== undefined && !updates.properties && Object.keys(updates).length === 1) {
+        property = 'backgroundColor';
+        newValue = updates.backgroundColor;
+    }
+
+    if (!property || !TEXT_STYLE_PROPS.includes(property)) return false;
+
+    const oldValue = property === 'fontFamily'
+        ? (object.properties?.fontFamily ?? TEXT_STYLE_DEFAULTS.fontFamily)
+        : (object[property] ?? object.properties?.[property] ?? TEXT_STYLE_DEFAULTS[property]);
+
+    if (oldValue === newValue) return false;
+
+    const command = new UpdateTextStyleCommand(core, objectId, property, oldValue, newValue);
+    core.history.executeCommand(command);
+    return true;
+}
+
+const FRAME_PROP_KEYS = ['title'];
+
+/**
+ * Если updates содержит одно свойство фрейма — создаёт UpdateFramePropertiesCommand.
+ * Поддерживает: title, backgroundColor, type, lockedAspect.
+ * @returns {boolean} true, если команда создана и применена
+ */
+function tryCreateFramePropertiesCommand(core, object, objectId, updates) {
+    if (object.type !== 'frame') return false;
+
+    let property = null;
+    let oldValue = null;
+    let newValue = null;
+
+    if (updates.backgroundColor !== undefined && !updates.properties) {
+        property = 'backgroundColor';
+        newValue = updates.backgroundColor;
+        oldValue = object.backgroundColor ?? 0xFFFFFF;
+    } else if (updates.properties) {
+        const propKeys = Object.keys(updates.properties);
+        if (propKeys.length === 1 && propKeys[0] === 'title') {
+            property = 'title';
+            newValue = updates.properties.title;
+            oldValue = object.properties?.title ?? '';
+        }
+        // type и lockedAspect — только через UpdateFrameTypeCommand в панели (один шаг в истории)
+    }
+
+    if (!property) return false;
+    const supported = [...FRAME_PROP_KEYS, 'backgroundColor'];
+    if (!supported.includes(property)) return false;
+    if (oldValue === newValue) return false;
+
+    const command = new UpdateFramePropertiesCommand(core, objectId, property, oldValue, newValue);
+    core.history.executeCommand(command);
+    return true;
+}
+
+export function setupObjectLifecycleFlow(core) {
+    core.eventBus.on(Events.Tool.ObjectsDelete, ({ objects }) => {
+        const ids = Array.isArray(objects) ? objects : [];
+        if (ids.length === 0) return;
+        const command = new GroupDeleteCommand(core, ids);
+        core.history.executeCommand(command);
+    });
+
+    core.eventBus.on(Events.Tool.HitTest, (data) => {
+        const result = core.pixi.hitTest(data.x, data.y);
+        data.result = result;
+    });
+
+    core.eventBus.on(Events.Tool.GetObjectPosition, (data) => {
+        const pixiObject = core.pixi.objects.get(data.objectId);
+        if (!pixiObject) return;
+        const halfW = (pixiObject.width || 0) / 2;
+        const halfH = (pixiObject.height || 0) / 2;
+        data.position = { x: pixiObject.x - halfW, y: pixiObject.y - halfH };
+    });
+
+    core.eventBus.on(Events.Tool.GetObjectPixi, (data) => {
+        const pixiObject = core.pixi.objects.get(data.objectId);
+        data.pixiObject = pixiObject || null;
+    });
+
+    core.eventBus.on(Events.Tool.GetAllObjects, (data) => {
+        const result = [];
+        for (const [objectId, pixiObject] of core.pixi.objects.entries()) {
+            const bounds = pixiObject.getBounds();
+            result.push({
+                id: objectId,
+                pixi: pixiObject,
+                bounds: { x: bounds.x, y: bounds.y, width: bounds.width, height: bounds.height }
+            });
+        }
+        data.objects = result;
+    });
+
+    core.eventBus.on(Events.Tool.SelectionAll, () => {
+        if (core.toolManager?.getActiveTool()?.name !== 'select') return;
+        const req = { objects: [] };
+        core.eventBus.emit(Events.Tool.GetAllObjects, req);
+        const ids = (req.objects || []).map((o) => o.id);
+        if (ids.length > 0 && core.selectTool) {
+            core.selectTool.setSelection(ids);
+            core.selectTool.updateResizeHandles();
+        }
+    });
+
+    core.eventBus.on(Events.Tool.GetObjectSize, (data) => {
+        const objects = core.state.getObjects();
+        const object = objects.find(obj => obj.id === data.objectId);
+        if (object) {
+            data.size = { width: object.width, height: object.height };
+        }
+    });
+
+    core.eventBus.on(Events.Tool.GetObjectRotation, (data) => {
+        const pixiObject = core.pixi.objects.get(data.objectId);
+        if (pixiObject) {
+            data.rotation = pixiObject.rotation * 180 / Math.PI;
+        } else {
+            data.rotation = 0;
+        }
+    });
+
+    core.eventBus.on(Events.Tool.UpdateObjectContent, (data) => {
+        const { objectId, content } = data;
+        if (objectId && content !== undefined) {
+            core.pixi.updateObjectContent(objectId, content);
+        }
+    });
+
+    core.eventBus.on(Events.Tool.HideObjectText, (data) => {
+        const { objectId } = data;
+        if (objectId) {
+            core.pixi.hideObjectText(objectId);
+        }
+    });
+
+    core.eventBus.on(Events.Tool.ShowObjectText, (data) => {
+        const { objectId } = data;
+        if (objectId) {
+            core.pixi.showObjectText(objectId);
+        }
+    });
+
+    core.eventBus.on(Events.Tool.FindObjectByPosition, (data) => {
+        const { position, type } = data;
+        if (position && type) {
+            const foundObject = core.pixi.findObjectByPosition(position, type);
+            data.foundObject = foundObject;
+        }
+    });
+
+    core.eventBus.on(Events.Object.StateChanged, (data) => {
+        const { objectId, updates } = data;
+        if (!objectId || !updates || !core.state) return;
+
+        const objects = core.state.getObjects();
+        const object = objects.find(obj => obj.id === objectId);
+        if (!object) return;
+
+        const noteStyleChange = tryCreateNoteStyleCommand(core, object, objectId, updates);
+        if (noteStyleChange) return;
+
+        const textStyleChange = tryCreateTextStyleCommand(core, object, objectId, updates);
+        if (textStyleChange) return;
+
+        const framePropsChange = tryCreateFramePropertiesCommand(core, object, objectId, updates);
+        if (framePropsChange) return;
+
+        if (updates.properties && object.properties) {
+            Object.assign(object.properties, updates.properties);
+        }
+
+        const topLevelUpdates = { ...updates };
+        delete topLevelUpdates.properties;
+        Object.assign(object, topLevelUpdates);
+
+        const pixiObject = core.pixi.objects.get(objectId);
+        if (pixiObject && pixiObject._mb && pixiObject._mb.instance) {
+            const instance = pixiObject._mb.instance;
+
+            if (object.type === 'frame' && updates.properties && updates.properties.title !== undefined) {
+                if (instance.setTitle) {
+                    instance.setTitle(updates.properties.title);
+                }
+            }
+
+            if (object.type === 'frame' && updates.backgroundColor !== undefined) {
+                if (instance.setBackgroundColor) {
+                    instance.setBackgroundColor(updates.backgroundColor);
+                }
+            }
+
+            if (object.type === 'note' && updates.properties) {
+                if (instance.setStyle) {
+                    const styleUpdates = {};
+                    if (updates.properties.backgroundColor !== undefined) {
+                        styleUpdates.backgroundColor = updates.properties.backgroundColor;
+                    }
+                    if (updates.properties.borderColor !== undefined) {
+                        styleUpdates.borderColor = updates.properties.borderColor;
+                    }
+                    if (updates.properties.textColor !== undefined) {
+                        styleUpdates.textColor = updates.properties.textColor;
+                    }
+                    if (updates.properties.fontSize !== undefined) {
+                        styleUpdates.fontSize = updates.properties.fontSize;
+                    }
+                    if (updates.properties.fontFamily !== undefined) {
+                        styleUpdates.fontFamily = updates.properties.fontFamily;
+                    }
+
+                    if (Object.keys(styleUpdates).length > 0) {
+                        instance.setStyle(styleUpdates);
+                    }
+                }
+            }
+        }
+
+        core.state.markDirty();
+    });
+
+    core.eventBus.on(Events.Object.FileNameChange, (data) => {
+        const { objectId, oldName, newName } = data;
+        if (objectId && oldName !== undefined && newName !== undefined) {
+            const command = new EditFileNameCommand(core, objectId, oldName, newName);
+            core.history.executeCommand(command);
+        }
+    });
+
+    core.eventBus.on(Events.Object.ContentChange, (data) => {
+        const { objectId, oldContent, newContent } = data;
+        if (objectId && oldContent !== undefined && newContent !== undefined && oldContent !== newContent) {
+            const command = new UpdateContentCommand(core, objectId, oldContent, newContent);
+            command.setEventBus(core.eventBus);
+            core.history.executeCommand(command);
+        }
+    });
+
+    core.eventBus.on('file:metadata:updated', (data) => {
+        const { objectId, metadata } = data;
+        if (objectId && metadata) {
+            const objects = core.state.getObjects();
+            const objectData = objects.find(obj => obj.id === objectId);
+
+            if (objectData && objectData.type === 'file') {
+                if (!objectData.properties) {
+                    objectData.properties = {};
+                }
+
+                if (metadata.name && metadata.name !== objectData.properties.fileName) {
+                    objectData.properties.fileName = metadata.name;
+
+                    const pixiReq = { objectId, pixiObject: null };
+                    core.eventBus.emit(Events.Tool.GetObjectPixi, pixiReq);
+
+                    if (pixiReq.pixiObject && pixiReq.pixiObject._mb && pixiReq.pixiObject._mb.instance) {
+                        const fileInstance = pixiReq.pixiObject._mb.instance;
+                        if (typeof fileInstance.setFileName === 'function') {
+                            fileInstance.setFileName(metadata.name);
+                        }
+                    }
+
+                    core.state.markDirty();
+                }
+            }
+        }
+    });
+}

package/src/core/flows/SaveFlow.js

@@ -0,0 +1,34 @@
+import { Events } from '../events/Events.js';
+
+export function setupSaveFlow(core) {
+    core.eventBus.on(Events.Save.GetBoardData, (requestData) => {
+        requestData.data = core.getBoardData();
+    });
+
+    core.eventBus.on(Events.Grid.BoardDataChanged, ({ grid }) => {
+        try {
+            if (grid) {
+                if (!core.state.state.board) core.state.state.board = {};
+                core.state.state.board.grid = grid;
+                core.state.markDirty();
+            }
+        } catch (_) {}
+    });
+
+    core.eventBus.on(Events.Save.StatusChanged, () => {
+    });
+
+    core.eventBus.on(Events.Save.Error, (data) => {
+        console.error('Save error:', data.error);
+    });
+
+    core.eventBus.on(Events.Save.Success, async () => {
+        try {
+            const result = await core.cleanupUnusedImages();
+            if (result.deletedCount > 0) {
+            }
+        } catch (error) {
+            console.warn('⚠️ Не удалось выполнить автоматическую очистку изображений:', error.message);
+        }
+    });
+}