@sequent-org/moodboard 1.4.65 → 1.4.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sequent-org/moodboard",
-  "version": "1.4.65",
+  "version": "1.4.67",
   "type": "module",
   "description": "Interactive moodboard",
   "main": "./src/index.js",

package/src/core/HistoryManager.js

@@ -41,7 +41,9 @@ export class HistoryManager {
             lastCommand.mergeWith(command);
             this._executeCommandSafely(lastCommand);
             this.eventBus.emit('history:changed', {
-                historySize: this.history.length
+                historySize: this.history.length,
+                canUndo: this.currentIndex >= 0,
+                canRedo: this.currentIndex < this.history.length - 1,
             });
             return;
         }
@@ -67,7 +69,9 @@ export class HistoryManager {
         // Уведомляем об изменении истории
         this.eventBus.emit(Events.History.Changed, {
             historySize: this.history.length,
-            currentCommand: command.toString()
+            currentCommand: command.toString(),
+            canUndo: this.currentIndex >= 0,
+            canRedo: this.currentIndex < this.history.length - 1,
         });
 
 
@@ -107,7 +111,9 @@ export class HistoryManager {
         this.currentIndex = -1;
         
         this.eventBus.emit(Events.History.Changed, {
-            historySize: 0
+            historySize: 0,
+            canUndo: false,
+            canRedo: false,
         });
 
 

package/src/core/SaveManager.js

@@ -26,6 +26,10 @@ export class SaveManager {
         // Если изменение пришло, пока предыдущий запрос ещё в полёте, помечаем
         // необходимость дозаписи: иначе последняя правка перед выходом теряется.
         this._pendingResave = false;
+        // Счётчик последовательных rebase после 409: ограничивает цикл
+        // «reload → reapply → resave → снова 409», если сервер уходит вперёд
+        // в каждом раунде. Сбрасывается при успешном сохранении.
+        this._staleRebaseCount = 0;
         this._listenersAttached = false;
         this._handlers = {};
         
@@ -134,9 +138,13 @@ export class SaveManager {
         }
         this.isRequestInProgress = true;
 
+        // Доступно и в catch: на 409 нужно переприменить именно эти локальные данные.
+        let pendingSaveData = null;
+
         try {
             // Получаем данные для сохранения
             const saveData = data || await this.getBoardData();
+            pendingSaveData = saveData;
 
             // Защита: если данные не получены (например, при уничтожении/отписке обработчиков) — выходим без ошибки
             if (!saveData || typeof saveData !== 'object') {
@@ -194,6 +202,7 @@ export class SaveManager {
                 this.lastSavedData = JSON.parse(JSON.stringify(saveData));
                 this.hasUnsavedChanges = false;
                 this.retryCount = 0;
+                this._staleRebaseCount = 0;
                 this.updateSaveStatus('saved');
                 
                 // Эмитируем событие успешного сохранения
@@ -214,26 +223,49 @@ export class SaveManager {
                 return;
             }
 
-            // 409 stale_base_version: экземпляр устарел — нельзя перезаписывать сервер.
-            // Перечитываем latest. Retry исключён — это не transient-ошибка.
+            // 409 stale_base_version: локальный baseVersion отстал от сервера
+            // (типично — гонка «финальное сохранение при закрытии ещё не доехало,
+            // а переоткрытие уже загрузило предыдущую версию»). Перезаписывать
+            // сервер целиком нельзя — затрём чужие правки. Поэтому:
+            //   1) перечитываем latest (reloadHandler выставляет актуальный baseVersion),
+            //   2) переприменяем поверх локальные НОВЫЕ объекты (например, только что
+            //      нарисованный штрих) — reloadHandler возвращает их число,
+            //   3) пересохраняем с актуальной версией.
+            // Так рисунок не теряется, а аддитивный merge не удаляет серверные данные.
             if (error?.code === 'stale_base_version') {
                 console.warn(
                     'SaveManager: 409 stale_base_version — версия доски устарела. Перечитываю latest с сервера...',
                     error.message
                 );
                 if (typeof this._reloadHandler === 'function') {
+                    this._staleRebaseCount++;
                     try {
-                        await this._reloadHandler();
-                        // После перезагрузки сбрасываем кеш: следующее изменение
-                        // сохранится с актуальной версией без ложного дедупа.
+                        const result = (this._staleRebaseCount <= this.options.maxRetries)
+                            ? await this._reloadHandler({
+                                pendingData: pendingSaveData,
+                                currentVersion: error.currentVersion ?? null,
+                            })
+                            : await this._reloadHandler();
+                        // После перезагрузки сбрасываем кеш дедупа: пересохранение
+                        // должно уйти на сервер с актуальной версией.
                         this.lastSavedData = null;
-                        this.hasUnsavedChanges = false;
-                        this.updateSaveStatus('saved');
-                        console.warn(
-                            'SaveManager: состояние доски перечитано с сервера. ' +
-                            'Локальное pending-изменение отменено во избежание затирания чужих данных. ' +
-                            'TODO: переприменить pending-изменение поверх свежего состояния.'
-                        );
+
+                        const reapplied = Number(result?.reapplied) || 0;
+                        if (reapplied > 0 && this._staleRebaseCount <= this.options.maxRetries) {
+                            // Локальные новые объекты переприменены поверх свежего
+                            // состояния — пересохраняем их с актуальным baseVersion.
+                            this.hasUnsavedChanges = true;
+                            this._pendingResave = true; // finally запустит saveImmediately()
+                            this.updateSaveStatus('saving');
+                        } else {
+                            // Нечего переприменять (или превышен лимит rebase) —
+                            // оставляем перечитанное серверное состояние как есть.
+                            this.hasUnsavedChanges = false;
+                            this.updateSaveStatus('saved');
+                            if (this._staleRebaseCount > this.options.maxRetries) {
+                                console.warn('SaveManager: превышен лимит rebase после 409, оставляю серверное состояние.');
+                            }
+                        }
                     } catch (reloadErr) {
                         console.error('SaveManager: ошибка перечитывания после 409:', reloadErr);
                         this.updateSaveStatus('error', reloadErr.message);

package/src/core/index.js

@@ -230,6 +230,12 @@ export class CoreMoodBoard {
                     historySize: data.historySize,
                 });
             }
+            if (data && ('canUndo' in data || 'canRedo' in data)) {
+                this.eventBus.emit(Events.UI.UpdateHistoryButtons, {
+                    canUndo: !!data.canUndo,
+                    canRedo: !!data.canRedo,
+                });
+            }
         });
     }
 

package/src/moodboard/integration/MoodBoardEventBindings.js

@@ -111,6 +111,62 @@ export function bindTopbarEvents(board) {
     });
 }
 
+/**
+ * Аддитивно переприменяет локальные объекты, которых нет в текущем (только что
+ * перечитанном с сервера) состоянии доски. Вызывается после 409
+ * stale_base_version, чтобы не потерять только что созданные локально объекты
+ * (например, нарисованный штрих). Серверные объекты не трогаем — это безопасный
+ * union по id, а не перезапись чужих данных.
+ * @returns {number} сколько объектов переприменено
+ */
+function reapplyLocalOnlyObjects(board, pendingData) {
+    const core = board?.coreMoodboard;
+    if (!core || typeof core.createObjectFromData !== 'function') {
+        return 0;
+    }
+
+    const pendingObjects = Array.isArray(pendingData?.boardData?.objects)
+        ? pendingData.boardData.objects
+        : Array.isArray(pendingData?.objects)
+            ? pendingData.objects
+            : [];
+    if (pendingObjects.length === 0) {
+        return 0;
+    }
+
+    const currentObjects = Array.isArray(core.state?.state?.objects)
+        ? core.state.state.objects
+        : [];
+    const currentIds = new Set(currentObjects.map((obj) => obj && obj.id).filter(Boolean));
+
+    let reapplied = 0;
+    for (const obj of pendingObjects) {
+        if (!obj || !obj.id || currentIds.has(obj.id)) {
+            continue;
+        }
+        try {
+            // Клонируем: createObjectFromData мутирует objectData (transform/properties).
+            const created = core.createObjectFromData(JSON.parse(JSON.stringify(obj)));
+            if (created) {
+                reapplied++;
+            }
+        } catch (error) {
+            console.warn('⚠️ rebase после 409: не удалось переприменить объект', obj.id, error);
+        }
+    }
+
+    if (reapplied > 0) {
+        // PIXI-объекты (рисунок) перерисовываются сразу; для текстовых/заметок
+        // синхронизируем HTML-оверлеи, как это делает DataManager.loadData.
+        setTimeout(() => {
+            try { window.moodboardHtmlTextLayer?.rebuildFromState?.(); } catch (_) {}
+            try { window.moodboardHtmlTextLayer?.updateAll?.(); } catch (_) {}
+        }, 0);
+    }
+
+    return reapplied;
+}
+
 export function bindSaveCallbacks(board) {
     if (!board.coreMoodboard || !board.coreMoodboard.eventBus) {
         return;
@@ -125,9 +181,15 @@ export function bindSaveCallbacks(board) {
             return (v !== null && Number.isFinite(Number(v)) && Number(v) > 0) ? Number(v) : null;
         });
 
-        // На 409 stale_base_version — перечитываем latest с сервера, не затираем чужие данные.
-        saveManager.setReloadHandler(async () => {
+        // На 409 stale_base_version — перечитываем latest с сервера (не затираем
+        // чужие данные) и аддитивно переприменяем локальные НОВЫЕ объекты, которых
+        // ещё нет в свежем состоянии (например, только что нарисованный штрих).
+        // Возвращаем число переприменённых объектов, чтобы SaveManager понял,
+        // нужно ли пересохранять с актуальной версией.
+        saveManager.setReloadHandler(async (context = {}) => {
             await loadExistingBoard(board, null, { fallbackToSeedOnError: false });
+            const reapplied = reapplyLocalOnlyObjects(board, context?.pendingData);
+            return { reapplied };
         });
     }