@sequent-org/moodboard 1.0.0

package/src/core/commands/DeleteObjectCommand.js

@@ -0,0 +1,146 @@
+import { BaseCommand } from './BaseCommand.js';
+import { Events } from '../events/Events.js';
+
+/**
+ * Команда удаления объекта
+ */
+export class DeleteObjectCommand extends BaseCommand {
+    constructor(coreMoodboard, objectId) {
+        super('delete_object', `Удалить объект`);
+        this.coreMoodboard = coreMoodboard;
+        this.objectId = objectId;
+        
+        // Сохраняем данные объекта для возможности восстановления
+        const objects = this.coreMoodboard.state.getObjects();
+        const originalData = objects.find(obj => obj.id === objectId);
+        
+        if (!originalData) {
+            throw new Error(`Object with id ${objectId} not found`);
+        }
+
+        // Делаем глубокую копию данных объекта
+        this.objectData = JSON.parse(JSON.stringify(originalData));
+        
+        // Для изображений убедимся, что есть src URL для восстановления
+        if (this.objectData.type === 'image') {
+            console.log('🔧 DEBUG DeleteObjectCommand: исходные данные изображения:', {
+                id: this.objectData.id,
+                imageId: this.objectData.imageId,
+                src: this.objectData.src,
+                propertiesSrc: this.objectData.properties?.src,
+                hasBase64Src: !!(this.objectData.src && this.objectData.src.startsWith('data:')),
+                hasBase64Props: !!(this.objectData.properties?.src && this.objectData.properties.src.startsWith('data:'))
+            });
+            
+            if (this.objectData.imageId) {
+                const imageUrl = `/api/images/${this.objectData.imageId}/file`;
+                
+                // Всегда восстанавливаем URL из imageId для гарантии
+                // (может быть удален при предыдущих сохранениях)
+                this.objectData.src = imageUrl;
+                
+                if (!this.objectData.properties) {
+                    this.objectData.properties = {};
+                }
+                this.objectData.properties.src = imageUrl;
+                
+                console.log('🔧 DEBUG DeleteObjectCommand: обновленные данные изображения:', {
+                    id: this.objectData.id,
+                    imageId: this.objectData.imageId,
+                    src: this.objectData.src,
+                    propertiesSrc: this.objectData.properties?.src
+                });
+            } else {
+                console.warn('🔧 DEBUG DeleteObjectCommand: у изображения нет imageId, оставляем как есть');
+            }
+        }
+        
+        // Для файлов сохраняем информацию для возможной очистки с сервера
+        if (this.objectData.type === 'file') {
+            console.log('🔧 DEBUG DeleteObjectCommand: исходные данные файла:', {
+                id: this.objectData.id,
+                fileId: this.objectData.fileId,
+                fileName: this.objectData.properties?.fileName
+            });
+            
+            if (this.objectData.fileId) {
+                // Сохраняем fileId для удаления с сервера
+                this.fileIdToDelete = this.objectData.fileId;
+                console.log('🔧 DEBUG DeleteObjectCommand: файл будет удален с сервера:', this.fileIdToDelete);
+            }
+        }
+        
+        // Обновляем описание с типом объекта
+        this.description = `Удалить ${this.objectData.type}`;
+    }
+
+    async execute() {
+        // Удаляем объект из состояния и PIXI
+        this.coreMoodboard.state.removeObject(this.objectId);
+        this.coreMoodboard.pixi.removeObject(this.objectId);
+        
+        // Если это файловый объект с fileId, удаляем файл с сервера
+        if (this.fileIdToDelete && this.coreMoodboard.fileUploadService) {
+            try {
+                console.log('🗑️ Удаляем файл с сервера:', this.fileIdToDelete);
+                await this.coreMoodboard.fileUploadService.deleteFile(this.fileIdToDelete);
+                console.log('✅ Файл успешно удален с сервера:', this.fileIdToDelete);
+            } catch (error) {
+                console.warn('⚠️ Ошибка удаления файла с сервера:', error);
+                // Не останавливаем выполнение команды, так как объект уже удален из UI
+            }
+        }
+        
+        this.coreMoodboard.eventBus.emit(Events.Object.Deleted, { 
+            objectId: this.objectId 
+        });
+    }
+
+    undo() {
+        // DEBUG: Логируем состояние объекта при Undo
+        if (this.objectData.type === 'image') {
+            console.log('🔄 DEBUG Undo изображения:', {
+                id: this.objectData.id,
+                imageId: this.objectData.imageId,
+                src: this.objectData.src,
+                propertiesSrc: this.objectData.properties?.src,
+                hasBase64Src: !!(this.objectData.src && this.objectData.src.startsWith('data:')),
+                hasBase64Props: !!(this.objectData.properties?.src && this.objectData.properties.src.startsWith('data:'))
+            });
+        }
+        
+        // Специальная обработка для файловых объектов
+        if (this.objectData.type === 'file' && this.fileIdToDelete) {
+            console.log('🔄 DEBUG Undo файла:', {
+                id: this.objectData.id,
+                fileId: this.objectData.fileId,
+                fileName: this.objectData.properties?.fileName
+            });
+            
+            // Файл был удален с сервера, создаем объект с предупреждением
+            const restoredObjectData = { ...this.objectData };
+            if (restoredObjectData.properties) {
+                restoredObjectData.properties = {
+                    ...restoredObjectData.properties,
+                    fileName: `[УДАЛЕН] ${restoredObjectData.properties.fileName || 'файл'}`,
+                    isDeleted: true // Флаг для FileObject чтобы показать другую иконку
+                };
+            }
+            
+            // Восстанавливаем объект с измененными данными
+            this.coreMoodboard.state.addObject(restoredObjectData);
+            this.coreMoodboard.pixi.createObject(restoredObjectData);
+            
+            console.warn('⚠️ Файл восстановлен на холсте, но был удален с сервера');
+        } else {
+            // Восстанавливаем объект с сохраненными данными (для всех остальных типов)
+            this.coreMoodboard.state.addObject(this.objectData);
+            this.coreMoodboard.pixi.createObject(this.objectData);
+        }
+        
+        this.coreMoodboard.eventBus.emit(Events.Object.Created, { 
+            objectId: this.objectId, 
+            objectData: this.objectData 
+        });
+    }
+}

package/src/core/commands/EditFileNameCommand.js

@@ -0,0 +1,107 @@
+import { BaseCommand } from './BaseCommand.js';
+import { Events } from '../events/Events.js';
+
+/**
+ * Команда изменения названия файла
+ */
+export class EditFileNameCommand extends BaseCommand {
+    constructor(coreMoodboard, objectId, oldName, newName) {
+        super('edit_file_name', `Переименовать файл`);
+        this.coreMoodboard = coreMoodboard;
+        this.objectId = objectId;
+        this.oldName = oldName;
+        this.newName = newName;
+        
+        // Обновляем описание с названиями
+        this.description = `Переименовать файл "${this.oldName}" → "${this.newName}"`;
+    }
+
+    async execute() {
+        // Устанавливаем новое название
+        await this._setFileName(this.newName);
+    }
+
+    async undo() {
+        // Возвращаем старое название
+        await this._setFileName(this.oldName);
+    }
+
+    /**
+     * Можно объединить команды переименования одного и того же файла
+     */
+    canMergeWith(otherCommand) {
+        return otherCommand instanceof EditFileNameCommand &&
+               otherCommand.objectId === this.objectId;
+    }
+
+    /**
+     * Объединяет команды переименования - берет начальное название из первой команды
+     * и конечное название из второй
+     */
+    mergeWith(otherCommand) {
+        if (!this.canMergeWith(otherCommand)) {
+            throw new Error('Cannot merge commands');
+        }
+        
+        // Обновляем конечное название
+        this.newName = otherCommand.newName;
+        this.description = `Переименовать файл "${this.oldName}" → "${this.newName}"`;
+        this.timestamp = otherCommand.timestamp;
+    }
+
+    /**
+     * Устанавливает название файла
+     * @private
+     */
+    async _setFileName(fileName) {
+        // Обновляем в состоянии
+        const objects = this.coreMoodboard.state.getObjects();
+        const objectData = objects.find(obj => obj.id === this.objectId);
+        
+        if (objectData) {
+            // Обновляем properties объекта
+            if (!objectData.properties) {
+                objectData.properties = {};
+            }
+            objectData.properties.fileName = fileName;
+            
+            // Синхронизируем с сервером, если есть fileId
+            if (objectData.fileId && this.coreMoodboard.fileUploadService) {
+                try {
+                    console.log('🔄 Синхронизируем название файла с сервером:', { fileId: objectData.fileId, fileName });
+                    await this.coreMoodboard.fileUploadService.updateFileMetadata(objectData.fileId, { 
+                        fileName: fileName 
+                    });
+                    console.log('✅ Название файла успешно обновлено на сервере');
+                } catch (error) {
+                    console.warn('⚠️ Ошибка синхронизации названия файла с сервером:', error);
+                    // Не останавливаем выполнение, продолжаем с локальным обновлением
+                }
+            }
+            
+            // Обновляем состояние
+            this.coreMoodboard.state.markDirty();
+            
+            // Обновляем визуальное представление
+            const pixiReq = { objectId: this.objectId, pixiObject: null };
+            this.coreMoodboard.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(fileName);
+                }
+            }
+            
+            // Эмитим событие обновления объекта
+            this.coreMoodboard.eventBus.emit(Events.Object.Updated, { 
+                objectId: this.objectId,
+                type: 'fileName',
+                oldValue: this.oldName,
+                newValue: fileName
+            });
+        } else {
+            console.warn(`EditFileNameCommand: объект с ID ${this.objectId} не найден`);
+        }
+    }
+}

package/src/core/commands/GroupMoveCommand.js

@@ -0,0 +1,47 @@
+import { BaseCommand } from './BaseCommand.js';
+import { Events } from '../events/Events.js';
+
+/**
+ * Команда перемещения группы объектов одной операцией (для Undo/Redo)
+ */
+export class GroupMoveCommand extends BaseCommand {
+    /**
+     * @param {CoreMoodBoard} core
+     * @param {Array<{id:string, from:{x:number,y:number}, to:{x:number,y:number}}>} moves
+     */
+    constructor(core, moves) {
+        super('group-move', 'Переместить группу объектов');
+        this.core = core;
+        this.moves = moves || [];
+    }
+
+    execute() {
+        // Применяем конечные позиции ко всем объектам
+        for (const item of this.moves) {
+            this.core.updateObjectPositionDirect(item.id, item.to);
+            this.emit(Events.Object.TransformUpdated, {
+                objectId: item.id,
+                type: 'position',
+                position: item.to
+            });
+        }
+    }
+
+    undo() {
+        // Возвращаем исходные позиции
+        for (const item of this.moves) {
+            this.core.updateObjectPositionDirect(item.id, item.from);
+            this.emit(Events.Object.TransformUpdated, {
+                objectId: item.id,
+                type: 'position',
+                position: item.from
+            });
+        }
+    }
+
+    getDescription() {
+        return `Переместить группу (${this.moves.length})`;
+    }
+}
+
+

package/src/core/commands/GroupReorderZCommand.js

@@ -0,0 +1,74 @@
+import { BaseCommand } from './BaseCommand.js';
+import { Events } from '../events/Events.js';
+
+/**
+ * Команда изменения порядка (z-order) группы объектов как единого блока
+ * Сохраняет внутренний порядок группы
+ */
+export class GroupReorderZCommand extends BaseCommand {
+    constructor(core, objectIds, mode) {
+        super('group-reorder-z', 'Изменить порядок слоя группы');
+        this.core = core;
+        this.objectIds = Array.from(objectIds || []);
+        this.mode = mode; // 'front' | 'back' | 'forward' | 'backward'
+        this.beforeOrder = null; // снимок порядка ids массива state
+        this.afterOrder = null;
+    }
+
+    execute() {
+        this.beforeOrder = (this.core.state.state.objects || []).map(o => o.id);
+        this.reorder(this.mode);
+        this.afterOrder = (this.core.state.state.objects || []).map(o => o.id);
+    }
+
+    undo() {
+        if (!this.beforeOrder) return;
+        this.applyOrder(this.beforeOrder);
+    }
+
+    applyOrder(idOrder) {
+        const map = new Map((this.core.state.state.objects || []).map(o => [o.id, o]));
+        this.core.state.state.objects = idOrder.map(id => map.get(id)).filter(Boolean);
+        // Пересчет zIndex
+        const app = this.core.pixi?.app;
+        if (app) {
+            app.stage.sortableChildren = true;
+            (this.core.state.state.objects || []).forEach((o, i) => {
+                const pixi = this.core.pixi.objects.get(o.id);
+                if (pixi) pixi.zIndex = i;
+            });
+        }
+        this.core.state.markDirty();
+        this.emit(Events.Object.Reordered, { ids: this.objectIds });
+    }
+
+    reorder(mode) {
+        const arr = this.core.state.state.objects || [];
+        const ids = new Set(this.objectIds);
+        const selectedItems = arr.filter(o => ids.has(o.id));
+        const others = arr.filter(o => !ids.has(o.id));
+        const indices = arr.map((o, i) => ({ id: o.id, i })).filter(p => ids.has(p.id)).map(p => p.i).sort((a,b)=>a-b);
+        const minIdx = indices[0] ?? 0;
+        const othersBefore = arr.slice(0, minIdx).filter(o => !ids.has(o.id)).length;
+        let insertPos = othersBefore;
+        switch (mode) {
+            case 'front': insertPos = others.length; break;
+            case 'back': insertPos = 0; break;
+            case 'forward': insertPos = Math.min(othersBefore + 1, others.length); break;
+            case 'backward': insertPos = Math.max(othersBefore - 1, 0); break;
+        }
+        this.core.state.state.objects = [...others.slice(0, insertPos), ...selectedItems, ...others.slice(insertPos)];
+        // Пересчет zIndex
+        const app = this.core.pixi?.app;
+        if (app) {
+            app.stage.sortableChildren = true;
+            (this.core.state.state.objects || []).forEach((o, i) => {
+                const pixi = this.core.pixi.objects.get(o.id);
+                if (pixi) pixi.zIndex = i;
+            });
+        }
+        this.core.state.markDirty();
+    }
+}
+
+

package/src/core/commands/GroupResizeCommand.js

@@ -0,0 +1,37 @@
+import { BaseCommand } from './BaseCommand.js';
+import { Events } from '../events/Events.js';
+
+/**
+ * Команда изменения размера группы объектов одной операцией (Undo/Redo)
+ */
+export class GroupResizeCommand extends BaseCommand {
+    /**
+     * @param {CoreMoodBoard} core
+     * @param {Array<{id:string, fromSize:{width:number,height:number}, toSize:{width:number,height:number}, fromPos:{x:number,y:number}, toPos:{x:number,y:number}, type?:string}>} changes
+     */
+    constructor(core, changes) {
+        super('group-resize', 'Изменить размер группы объектов');
+        this.core = core;
+        this.changes = changes || [];
+    }
+
+    execute() {
+        for (const c of this.changes) {
+            this.core.updateObjectSizeAndPositionDirect(c.id, c.toSize, c.toPos, c.type || null);
+            this.emit(Events.Object.TransformUpdated, { objectId: c.id, type: 'resize', size: c.toSize, position: c.toPos });
+        }
+    }
+
+    undo() {
+        for (const c of this.changes) {
+            this.core.updateObjectSizeAndPositionDirect(c.id, c.fromSize, c.fromPos, c.type || null);
+            this.emit(Events.Object.TransformUpdated, { objectId: c.id, type: 'resize', size: c.fromSize, position: c.fromPos });
+        }
+    }
+
+    getDescription() {
+        return `Изменить размер группы (${this.changes.length})`;
+    }
+}
+
+

package/src/core/commands/GroupRotateCommand.js

@@ -0,0 +1,41 @@
+import { BaseCommand } from './BaseCommand.js';
+import { Events } from '../events/Events.js';
+
+/**
+ * Команда поворота группы объектов одной операцией (для Undo/Redo)
+ */
+export class GroupRotateCommand extends BaseCommand {
+    /**
+     * @param {CoreMoodBoard} core
+     * @param {Array<{id:string, fromAngle:number, toAngle:number, fromPos:{x:number,y:number}, toPos:{x:number,y:number}}>} changes
+     */
+    constructor(core, changes) {
+        super('group-rotate', 'Повернуть группу объектов');
+        this.core = core;
+        this.changes = changes || [];
+    }
+
+    execute() {
+        for (const c of this.changes) {
+            this.core.updateObjectRotationDirect(c.id, c.toAngle);
+            this.core.updateObjectPositionDirect(c.id, c.toPos);
+            this.emit(Events.Object.TransformUpdated, { objectId: c.id, type: 'rotation', angle: c.toAngle });
+            this.emit(Events.Object.TransformUpdated, { objectId: c.id, type: 'position', position: c.toPos });
+        }
+    }
+
+    undo() {
+        for (const c of this.changes) {
+            this.core.updateObjectRotationDirect(c.id, c.fromAngle);
+            this.core.updateObjectPositionDirect(c.id, c.fromPos);
+            this.emit(Events.Object.TransformUpdated, { objectId: c.id, type: 'rotation', angle: c.fromAngle });
+            this.emit(Events.Object.TransformUpdated, { objectId: c.id, type: 'position', position: c.fromPos });
+        }
+    }
+
+    getDescription() {
+        return `Повернуть группу (${this.changes.length})`;
+    }
+}
+
+

package/src/core/commands/MoveObjectCommand.js

@@ -0,0 +1,89 @@
+import { BaseCommand } from './BaseCommand.js';
+import { Events } from '../events/Events.js';
+
+/**
+ * Команда перемещения объекта
+ */
+export class MoveObjectCommand extends BaseCommand {
+    constructor(coreMoodboard, objectId, oldPosition, newPosition) {
+        super('move_object', `Переместить объект`);
+        this.coreMoodboard = coreMoodboard;
+        this.objectId = objectId;
+        this.oldPosition = { ...oldPosition };
+        this.newPosition = { ...newPosition };
+        
+        // Обновляем описание с координатами
+        this.description = `Переместить объект (${Math.round(this.oldPosition.x)}, ${Math.round(this.oldPosition.y)}) → (${Math.round(this.newPosition.x)}, ${Math.round(this.newPosition.y)})`;
+    }
+
+    execute() {
+        // Устанавливаем новую позицию
+        this._setPosition(this.newPosition);
+
+    }
+
+    undo() {
+        // Возвращаем старую позицию
+        this._setPosition(this.oldPosition);
+
+    }
+
+    _setPosition(position) {
+        // Обновляем позицию в PIXI (x/y — центр), position — левый-верх
+        const pixiObject = this.coreMoodboard.pixi.objects.get(this.objectId);
+        if (pixiObject) {
+            const halfW = (pixiObject.width || 0) / 2;
+            const halfH = (pixiObject.height || 0) / 2;
+            pixiObject.x = position.x + halfW;
+            pixiObject.y = position.y + halfH;
+        }
+        
+        // Обновляем позицию в состоянии (левый-верх; без эмита события)
+        const objects = this.coreMoodboard.state.state.objects;
+        const object = objects.find(obj => obj.id === this.objectId);
+        if (object) {
+            object.position = { ...position };
+            
+            // Помечаем, что координаты уже скомпенсированы для pivot
+            if (!object.transform) {
+                object.transform = {};
+            }
+            object.transform.pivotCompensated = true;
+            
+            this.coreMoodboard.state.markDirty();
+        }
+        
+        // Уведомляем о том, что объект был изменен (для обновления ручек)
+        if (this.eventBus) {
+            this.eventBus.emit(Events.Object.TransformUpdated, {
+                objectId: this.objectId,
+                type: 'position',
+                position: position
+            });
+        }
+    }
+
+    /**
+     * Можно ли объединить с другой командой перемещения того же объекта
+     */
+    canMergeWith(otherCommand) {
+        return otherCommand instanceof MoveObjectCommand && 
+               otherCommand.objectId === this.objectId;
+    }
+
+    /**
+     * Объединить с другой командой перемещения
+     */
+    mergeWith(otherCommand) {
+        if (!this.canMergeWith(otherCommand)) {
+            throw new Error('Cannot merge with this command');
+        }
+        
+        // Обновляем конечную позицию
+        this.newPosition = { ...otherCommand.newPosition };
+        this.description = `Переместить объект (${Math.round(this.oldPosition.x)}, ${Math.round(this.oldPosition.y)}) → (${Math.round(this.newPosition.x)}, ${Math.round(this.newPosition.y)})`;
+        this.timestamp = otherCommand.timestamp; // Обновляем время последнего изменения
+        
+
+    }
+}

package/src/core/commands/PasteObjectCommand.js

@@ -0,0 +1,103 @@
+import { BaseCommand } from './BaseCommand.js';
+import { Events } from '../events/Events.js';
+import { generateObjectId } from '../../utils/objectIdGenerator.js';
+
+/**
+ * Команда вставки объекта
+ */
+export class PasteObjectCommand extends BaseCommand {
+    constructor(coreMoodboard, pastePosition = null) {
+        super();
+        this.coreMoodboard = coreMoodboard;
+        this.pastePosition = pastePosition;
+        this.newObjectId = null;
+        this.newObjectData = null;
+    }
+
+    execute() {
+        // Проверяем, есть ли что-то в буфере обмена
+        if (!this.coreMoodboard.clipboard || this.coreMoodboard.clipboard.type !== 'object') {
+            return;
+        }
+
+        // Получаем данные из буфера обмена
+        const originalData = this.coreMoodboard.clipboard.data;
+        
+        // Создаем новый объект на основе скопированного
+        this.newObjectData = JSON.parse(JSON.stringify(originalData));
+        
+        // Генерируем уникальный ID с проверкой коллизий
+        const exists = (id) => {
+            const inState = (this.coreMoodboard.state.state.objects || []).some(o => o.id === id);
+            const inPixi = this.coreMoodboard.pixi?.objects?.has ? this.coreMoodboard.pixi.objects.has(id) : false;
+            return inState || inPixi;
+        };
+        this.newObjectId = generateObjectId(exists);
+        this.newObjectData.id = this.newObjectId;
+        
+        // Сохраняем ID оригинального объекта для отслеживания копий
+        this.newObjectData.originalId = originalData.id;
+        
+        // Устанавливаем позицию вставки
+        if (this.pastePosition) {
+            this.newObjectData.position = { ...this.pastePosition };
+        } else {
+            // Если позиция не указана, смещаем относительно оригинала
+            // Проверяем, сколько копий этого объекта уже создано
+            const existingObjects = this.coreMoodboard.state.state.objects;
+            const originalId = originalData.id;
+            
+            // Ищем все копии этого конкретного объекта
+            const copies = existingObjects.filter(obj => 
+                obj.originalId === originalId || // Копии оригинального объекта
+                (obj.id === originalId && obj.originalId) // Если оригинал сам является копией
+            );
+            
+            // Рассчитываем смещение на основе количества копий
+            const offsetMultiplier = copies.length + 1;
+            const offsetStep = 25; // Шаг смещения в пикселях
+            
+            console.log(`📋 Вставка копии объекта ${originalId}: найдено ${copies.length} существующих копий, смещение ${offsetStep * offsetMultiplier}px`);
+            
+            this.newObjectData.position = {
+                x: originalData.position.x + (offsetStep * offsetMultiplier),
+                y: originalData.position.y + (offsetStep * offsetMultiplier)
+            };
+        }
+        
+        // Сбрасываем флаг компенсации pivot для нового объекта
+        if (!this.newObjectData.transform) {
+            this.newObjectData.transform = {};
+        }
+        this.newObjectData.transform.pivotCompensated = false;
+        
+        // Добавляем в состояние
+        this.coreMoodboard.state.addObject(this.newObjectData);
+        
+        // Создаем PIXI объект
+        this.coreMoodboard.pixi.createObject(this.newObjectData);
+        
+        this.emit(Events.Object.Pasted, {
+            originalId: originalData.id,
+            newId: this.newObjectId,
+            objectData: this.newObjectData
+        });
+    }
+
+    undo() {
+        if (this.newObjectId) {
+            // Удаляем созданный объект
+            this.coreMoodboard.state.removeObject(this.newObjectId);
+            this.coreMoodboard.pixi.removeObject(this.newObjectId);
+            
+            // Соответствующего константного события нет — остаёмся без эмита или используем Object.Deleted, если надо глобально
+            this.emit(Events.Object.Deleted, {
+                objectId: this.newObjectId
+            });
+        }
+    }
+
+    getDescription() {
+        return `Вставить объект`;
+    }
+}