@sequent-org/moodboard 1.4.57 → 1.4.58

package/src/ui/HtmlTextLayer.js

@@ -4,6 +4,13 @@ import { Events } from '../core/events/Events.js';
 import * as PIXI from 'pixi.js';
 import { renderRichText, hasMath } from '../utils/richText.js';
 import { renderTextList } from './text-properties/TextListRenderer.js';
+import {
+    applyTextStyles,
+    resolveLineHeightRatio,
+    computeTextRightPadPx,
+    resolveStaticTextPadding,
+    TEXT_BOX_BOTTOM_PAD_PX,
+} from '../services/text/TextBoxMetrics.js';
 
 gsap.registerPlugin(CustomEase);
 const TEXT_HOVER_EASE = 'hoverLiftSpring';
@@ -45,28 +52,6 @@ function resolveMarkdown(properties, content) {
     return looksLikeMarkdown(content) || hasMath(content);
 }
 
-/**
- * Возвращает коэффициент межстрочного интервала по базовому (немасштабированному) размеру шрифта.
- * Коэффициент зависит от базового размера, а не от отрисованного, — это гарантирует,
- * что соотношение line-height/font-size остаётся постоянным при любом зуме.
- * @param {number} baseFontSizePx — базовый размер шрифта без учёта зума
- * @param {object|undefined} properties
- * @returns {number} коэффициент (не пиксели)
- */
-function resolveLineHeightRatio(baseFontSizePx, properties) {
-    if (typeof properties?.lineHeight === 'number') {
-        return properties.lineHeight;
-    }
-    const fs = baseFontSizePx;
-    if (fs <= 12) return 1.40;
-    if (fs <= 18) return 1.34;
-    if (fs <= 36) return 1.26;
-    if (fs <= 48) return 1.24;
-    if (fs <= 72) return 1.22;
-    if (fs <= 96) return 1.20;
-    return 1.18;
-}
-
 /**
  * Строит безопасный HTML-фрагмент с кликабельными ссылками по массиву диапазонов.
  * Символы вне ссылок экранируются через textContent. Диапазоны не должны пересекаться.
@@ -97,6 +82,58 @@ function _buildHtmlWithLinks(content, links) {
     return result;
 }
 
+/**
+ * Строит HTML-фрагмент с диапазонами подсветки и/или ссылок.
+ * Пересечение highlight + link обрабатывается через набор граничных точек:
+ * внутри перекрытия порядок вложения — <a><mark>текст</mark></a>.
+ * @param {string} content
+ * @param {Array<{start:number, end:number, url:string}>|null} links
+ * @param {Array<{start:number, end:number, color:string}>|null} highlights
+ * @returns {string} готовый innerHTML
+ */
+export function buildHtmlWithRanges(content, links, highlights) {
+    const validLinks = (links || [])
+        .filter(l => typeof l.start === 'number' && typeof l.end === 'number' && l.end > l.start && l.url);
+    const validHighlights = (highlights || [])
+        .filter(h => typeof h.start === 'number' && typeof h.end === 'number' && h.end > h.start && h.color);
+
+    if (validLinks.length === 0 && validHighlights.length === 0) return _escapeHtml(content);
+    if (validHighlights.length === 0) return _buildHtmlWithLinks(content, validLinks);
+
+    // Строим набор граничных точек всех диапазонов, делим текст на сегменты
+    const boundaries = new Set([0, content.length]);
+    for (const l of validLinks) {
+        boundaries.add(Math.max(0, l.start));
+        boundaries.add(Math.min(content.length, l.end));
+    }
+    for (const h of validHighlights) {
+        boundaries.add(Math.max(0, h.start));
+        boundaries.add(Math.min(content.length, h.end));
+    }
+
+    const points = [...boundaries].sort((a, b) => a - b);
+
+    let result = '';
+    for (let i = 0; i < points.length - 1; i++) {
+        const s = points[i];
+        const e = points[i + 1];
+        let text = _escapeHtml(content.slice(s, e));
+
+        const hi = validHighlights.find(h => h.start <= s && h.end >= e);
+        const link = validLinks.find(l => l.start <= s && l.end >= e);
+
+        if (hi) {
+            text = `<mark style="background-color: ${_escapeAttr(hi.color)}">${text}</mark>`;
+        }
+        if (link) {
+            text = `<a href="${_escapeAttr(link.url)}" target="_blank" rel="noopener noreferrer" class="mb-text-link">${text}</a>`;
+        }
+        result += text;
+    }
+
+    return result;
+}
+
 function _escapeHtml(str) {
     return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
@@ -454,33 +491,28 @@ export class HtmlTextLayer {
         const color = objectData.color || props.color || props.textColor || '#000000';
         const backgroundColor = objectData.backgroundColor || props.backgroundColor || 'transparent';
 
-        // Безразмерный множитель line-height: браузер сам считает интервал относительно
-        // font-size, поэтому соотношение строк не зависит от зума и не страдает от округления.
         const baseFs = objectData.fontSize || props.fontSize || 32;
-        const baseLineHeight = resolveLineHeightRatio(baseFs, props);
 
         const content = objectData.content || objectData.properties?.content || '';
         const isMarkdown = resolveMarkdown(objectData.properties, content);
         if (isMarkdown) el.classList.add('mb-text--md');
+        // Единый набор текстовых параметров (шрифт, line-height, начертание, выравнивание).
+        // Тот же вызов используется в редакторе — гарантирует идентичный рендер в обоих режимах.
+        applyTextStyles(el, {
+            fontSizePx: baseFs,
+            baseFontSizePx: baseFs,
+            fontFamily,
+            properties: props,
+        });
         el.style.color = color;
-        el.style.fontFamily = fontFamily;
         el.style.backgroundColor = backgroundColor === 'transparent' ? '' : backgroundColor;
-        el.style.lineHeight = `${baseLineHeight}`;
         el.style.whiteSpace = isMarkdown ? 'normal' : 'pre';
         el.style.overflow = 'visible';
         if (isMarkdown) el.style.overflowWrap = 'break-word';
-        el.style.letterSpacing = '0px';
-        el.style.fontKerning = 'normal';
-        el.style.textRendering = 'optimizeLegibility';
-        if (!isMarkdown) el.style.padding = '0';
-        // Начертания и выравнивание из properties
-        el.style.fontWeight = props.bold ? 'bold' : '';
-        el.style.fontStyle = props.italic ? 'italic' : '';
-        const initDec = [props.underline && 'underline', props.strikethrough && 'line-through'].filter(Boolean).join(' ');
-        el.style.textDecoration = initDec || '';
-        el.style.textAlign = props.textAlign || '';
+        el.style.padding = resolveStaticTextPadding({ isMarkdown, useList: false });
         const initLinks = !isMarkdown ? (props.links || null) : null;
-        this._syncElementContent(el, content, isMarkdown, initLinks);
+        const initHighlights = !isMarkdown ? (props.highlights || null) : null;
+        this._syncElementContent(el, content, isMarkdown, initLinks, initHighlights);
         // Базовые размеры сохраняем в dataset
         const fs = objectData.fontSize || objectData.properties?.fontSize || 32;
         const bw = Math.max(1, objectData.width || objectData.properties?.baseW || 160);
@@ -556,12 +588,17 @@ export class HtmlTextLayer {
             : Math.min(scaleX, scaleY);
         const sCss = s / res;
         const fontSizePx = Math.max(1, baseFS * sObj * sCss);
-        el.style.fontSize = `${fontSizePx}px`;
-        // Безразмерный множитель: интервал между строками масштабируется браузером
-        // пропорционально font-size, поэтому не зависит от зума и не страдает от округления.
-        const newLH = `${resolveLineHeightRatio(baseFS, obj.properties)}`;
-        if (el.style.lineHeight !== newLH) {
-            el.style.lineHeight = newLH;
+        // Единый набор текстовых параметров через общий модуль — тот же вызов, что в редакторе.
+        // Это гарантирует идентичный рендер глифов в статическом режиме и в режиме редактирования.
+        if (obj.type !== 'shape') {
+            const props = obj.properties || {};
+            const fontFamily = props.fontFamily || obj.fontFamily || 'Caveat, Arial, cursive';
+            applyTextStyles(el, {
+                fontSizePx,
+                baseFontSizePx: baseFS,
+                fontFamily,
+                properties: props,
+            });
         }
 
         // Позиция и габариты в CSS координатах - используем тот же подход что в HtmlHandlesLayer
@@ -588,10 +625,14 @@ export class HtmlTextLayer {
             // при вычислении CSS-позиции и размеров не нужно. Деление приводило к тому,
             // что при res < 1 (масштаб браузера ≠ 100%) HTML-текст уезжал относительно
             // собственных рамок и PIXI-объекта.
-            const left = offsetLeft + tl.x;
-            const top = offsetTop + tl.y;
-            const width = Math.max(1, (br.x - tl.x));
-            const height = Math.max(1, (br.y - tl.y));
+            // Округляем до целых px: inline-редактор позиционирует обёртку через Math.round
+            // (TextEditorPositioningService), а статический слой раньше писал дробный top —
+            // из-за этого глиф съезжал по вертикали на доли пикселя при выходе из редактора.
+            // Целочисленный screen-space обязателен по pixel-perfect integer contract.
+            const left = Math.round(offsetLeft + tl.x);
+            const top = Math.round(offsetTop + tl.y);
+            const width = Math.max(1, Math.round(br.x - tl.x));
+            const height = Math.max(1, Math.round(br.y - tl.y));
 
             // Применяем к элементу
             el.style.left = `${left}px`;
@@ -608,13 +649,13 @@ export class HtmlTextLayer {
             logHeight = height;
         } else {
             // Fallback к старому методу
-            const left = (tx + s * x) / res;
-            const top = (ty + s * y) / res;
+            const left = Math.round((tx + s * x) / res);
+            const top = Math.round((ty + s * y) / res);
             el.style.left = `${left}px`;
             el.style.top = `${top}px`;
             if (w && h) {
-                const cssW = Math.max(1, (w * s) / res);
-                const cssH = Math.max(1, (h * s) / res);
+                const cssW = Math.max(1, Math.round((w * s) / res));
+                const cssH = Math.max(1, Math.round((h * s) / res));
                 el.style.width = `${cssW}px`;
                 el.style.height = `${cssH}px`;
                 logWidth = cssW;
@@ -649,15 +690,9 @@ export class HtmlTextLayer {
             return;
         }
 
-        // Начертания и выравнивание из properties
-        const props = obj.properties || {};
-        el.style.fontWeight = props.bold ? 'bold' : '';
-        el.style.fontStyle = props.italic ? 'italic' : '';
-        const textDec = [props.underline && 'underline', props.strikethrough && 'line-through'].filter(Boolean).join(' ');
-        el.style.textDecoration = textDec || '';
-        el.style.textAlign = props.textAlign || '';
-
         // Текст: список или plain/markdown
+        // (fontWeight/fontStyle/textDecoration/textAlign/lineHeight уже выставлены applyTextStyles выше)
+        const props = obj.properties || {};
         const content = obj.content || obj.properties?.content;
         const listType = props.listType;
         const useList = listType && listType !== 'none';
@@ -684,11 +719,12 @@ export class HtmlTextLayer {
                 el.classList.remove('mb-text--md');
                 el.style.whiteSpace = 'normal';
                 el.style.overflowWrap = 'break-word';
-                el.style.padding = '';
+                el.style.padding = resolveStaticTextPadding({ isMarkdown: false, useList: true });
             } else {
                 el.dataset.renderedList = '';
                 const plainLinks = !isMarkdown ? (props.links || null) : null;
-                const contentChanged = this._syncElementContent(el, content, isMarkdown, plainLinks);
+                const plainHighlights = !isMarkdown ? (props.highlights || null) : null;
+                const contentChanged = this._syncElementContent(el, content, isMarkdown, plainLinks, plainHighlights);
                 if (contentChanged) {
                     console.log(`🔍 HtmlTextLayer: содержимое обновлено в updateOne для ${objectId}:`, content);
                 }
@@ -697,8 +733,12 @@ export class HtmlTextLayer {
                     el.classList.toggle('mb-text--md', isMarkdown);
                     el.style.whiteSpace = isMarkdown ? 'normal' : 'pre';
                     el.style.overflowWrap = isMarkdown ? 'break-word' : '';
-                    if (!isMarkdown) el.style.padding = '0';
                 }
+                // Паддинг задаём при каждом проходе, а не только при смене режима:
+                // после режима списка inline padding сброшен на CSS 0.3em, и без
+                // безусловного восстановления обычный текст сохраняет лишний отступ
+                // сверху — статическая рамка уезжает выше глифов относительно поля ввода.
+                el.style.padding = resolveStaticTextPadding({ isMarkdown, useList: false });
             }
         }
 
@@ -710,7 +750,7 @@ export class HtmlTextLayer {
         try {
             const hasContent = !!(el.textContent && el.textContent.trim());
             if (hasContent && !angle && !isMarkdown && !useList && !(props.textAlign && props.textAlign !== 'left')) {
-                const rightMargin = Math.ceil(fontSizePx * 0.7) + 6;
+                const rightMargin = computeTextRightPadPx(fontSizePx);
                 const prevWidth = el.style.width;
                 el.style.width = 'auto';
                 const contentW = Math.ceil(el.scrollWidth);
@@ -725,7 +765,7 @@ export class HtmlTextLayer {
         try {
             el.style.height = 'auto';
             // Добавим небольшой нижний отступ для хвостов букв, чтобы не отсекались (например, у «з»)
-            const hCss = Math.max(1, Math.round(el.scrollHeight + 2));
+            const hCss = Math.max(1, Math.round(el.scrollHeight + TEXT_BOX_BOTTOM_PAD_PX));
             el.style.height = `${hCss}px`;
             // Обновим высоту для лога, если её ещё не устанавливали
             if (!logHeight) {
@@ -745,26 +785,29 @@ export class HtmlTextLayer {
         });
     }
 
-    /** Обновляет innerHTML/textContent только при реальной смене content, флага markdown или ссылок */
-    _syncElementContent(el, content, isMarkdown, links) {
+    /** Обновляет innerHTML/textContent только при реальной смене content, флага markdown, ссылок или подсветки */
+    _syncElementContent(el, content, isMarkdown, links, highlights) {
         if (typeof content !== 'string') return false;
         const mdFlag = isMarkdown ? '1' : '0';
         const linksKey = (Array.isArray(links) && links.length > 0) ? JSON.stringify(links) : '';
+        const highlightsKey = (Array.isArray(highlights) && highlights.length > 0) ? JSON.stringify(highlights) : '';
         if (
             el.dataset.renderedContent === content &&
             el.dataset.renderedMd === mdFlag &&
-            (el.dataset.renderedLinks || '') === linksKey
+            (el.dataset.renderedLinks || '') === linksKey &&
+            (el.dataset.renderedHighlights || '') === highlightsKey
         ) return false;
         if (isMarkdown) {
             el.innerHTML = renderRichText(content);
-        } else if (linksKey) {
-            el.innerHTML = _buildHtmlWithLinks(content, links);
+        } else if (linksKey || highlightsKey) {
+            el.innerHTML = buildHtmlWithRanges(content, links, highlights);
         } else {
             el.textContent = content;
         }
         el.dataset.renderedContent = content;
         el.dataset.renderedMd = mdFlag;
         el.dataset.renderedLinks = linksKey;
+        el.dataset.renderedHighlights = highlightsKey;
         return true;
     }
 

package/src/ui/TextPropertiesPanel.js

@@ -11,7 +11,6 @@ import {
 import {
     applyTextAppearanceToDom,
     buildBackgroundColorUpdate,
-    buildHighlightColorUpdate,
     buildFontFamilyUpdate,
     buildFontSizeUpdate,
     buildMarkdownUpdate,
@@ -62,7 +61,7 @@ export class TextPropertiesPanel {
             position: 'absolute',
             inset: '0',
             pointerEvents: 'none',
-            zIndex: 10000,
+            zIndex: 10050,
         });
         this.container.appendChild(this.layer);
 
@@ -122,6 +121,8 @@ export class TextPropertiesPanel {
 
         if (this.panel) {
             this.panel.style.display = 'none';
+            this.panel.querySelectorAll('.tpp-more-dropdown.is-open').forEach((el) => el.classList.remove('is-open'));
+            this.panel.querySelectorAll('.ipp-btn.is-active').forEach((el) => el.classList.remove('is-active'));
         }
 
         this._hideColorDropdown();
@@ -213,11 +214,78 @@ export class TextPropertiesPanel {
         this._updateTextAppearance(this.currentId, { fontSize });
     }
 
+    _applyFormatToSelection(formatType, value) {
+        const activeEditor = document.querySelector('.moodboard-text-input');
+        if (!activeEditor || activeEditor.selectionStart === activeEditor.selectionEnd) {
+            return false;
+        }
+
+        const start = activeEditor.selectionStart;
+        const end = activeEditor.selectionEnd;
+        const text = activeEditor.value;
+        const selected = text.substring(start, end);
+        const before = text.substring(0, start);
+        const after = text.substring(end);
+        
+        let newSelected = selected;
+        
+        const toggleWrap = (str, prefix, suffix = prefix) => {
+            if (str.startsWith(prefix) && str.endsWith(suffix)) {
+                return str.substring(prefix.length, str.length - suffix.length);
+            }
+            return `${prefix}${str}${suffix}`;
+        };
+        
+        switch (formatType) {
+            case 'color': {
+                const cleanSelected = selected.replace(/<span[^>]*>/g, '').replace(/<\/span>/g, '');
+                newSelected = `<span style="color: ${value}">${cleanSelected}</span>`;
+                break;
+            }
+            case 'bold':
+                newSelected = toggleWrap(selected, '**');
+                break;
+            case 'italic':
+                newSelected = toggleWrap(selected, '*');
+                break;
+            case 'underline':
+                newSelected = toggleWrap(selected, '<u>', '</u>');
+                break;
+            case 'strikethrough':
+                newSelected = toggleWrap(selected, '~~');
+                break;
+        }
+        
+        activeEditor.value = before + newSelected + after;
+        
+        // Restore selection
+        activeEditor.selectionStart = start;
+        activeEditor.selectionEnd = start + newSelected.length;
+        
+        // Force markdown mode so HTML/MD tags are rendered
+        this.eventBus.emit(Events.Object.StateChanged, {
+            objectId: this.currentId,
+            updates: buildMarkdownUpdate(true),
+        });
+        
+        // Update the object's content
+        this.eventBus.emit(Events.Tool.UpdateObjectContent, {
+            objectId: this.currentId,
+            content: activeEditor.value
+        });
+        
+        return true;
+    }
+
     _changeTextColor(color) {
         if (!this.currentId) {
             return;
         }
 
+        if (this._applyFormatToSelection('color', color)) {
+            return;
+        }
+
         this.eventBus.emit(Events.Object.StateChanged, {
             objectId: this.currentId,
             updates: buildTextColorUpdate(color),
@@ -244,12 +312,39 @@ export class TextPropertiesPanel {
             return;
         }
 
-        this.eventBus.emit(Events.Object.StateChanged, {
-            objectId: this.currentId,
-            updates: buildHighlightColorUpdate(highlightColor),
-        });
+        const props = getObjectProperties(this.eventBus, this.currentId);
+        
+        // Получаем актуальный контент (из живого редактора, если он есть)
+        let contentLength = 0;
+        const editor = document.querySelector('.moodboard-text-input');
+        if (editor) {
+            contentLength = editor.value.length;
+        } else {
+            contentLength = (props?.content ?? '').length;
+        }
+
+        const sel = this._savedTextSelection;
+        // С выделением — диапазон выделения; без выделения — весь текст (как у ссылок),
+        // box-фон всего поля не используется.
+        const start = (sel && sel.end > sel.start) ? sel.start : 0;
+        const end = (sel && sel.end > sel.start) ? sel.end : contentLength;
 
-        this._updateTextAppearance(this.currentId, { highlightColor });
+        this._addHighlight(highlightColor, start, end, this.currentId);
+        this._savedTextSelection = null;
+    }
+
+    /**
+     * Снимок выделения активного текстового редактора. Вызывается на mousedown по
+     * UI подсветки ДО того, как фокус уйдёт из textarea (особенно перед нативным
+     * color-input, который гарантированно сбрасывает выделение).
+     */
+    _snapshotTextSelection() {
+        const editor = document.querySelector('.moodboard-text-input');
+        if (editor && typeof editor.selectionStart === 'number' && typeof editor.selectionEnd === 'number') {
+            this._savedTextSelection = { start: editor.selectionStart, end: editor.selectionEnd };
+        } else {
+            this._savedTextSelection = null;
+        }
     }
 
     _toggleFormat(prop) {
@@ -257,6 +352,10 @@ export class TextPropertiesPanel {
             return;
         }
 
+        if (this._applyFormatToSelection(prop, null)) {
+            return;
+        }
+
         const properties = getObjectProperties(this.eventBus, this.currentId);
         const newValue = !(properties ? Boolean(properties[prop]) : false);
 
@@ -360,6 +459,54 @@ export class TextPropertiesPanel {
         this._updateTextAppearance(targetId, { links: newLinks });
     }
 
+    /**
+     * Добавляет/убирает цветовой диапазон подсветки в properties.highlights.
+     * Не вставляет теги в текст — textarea остаётся чистой.
+     * @param {string} color — CSS-цвет или 'transparent' (удалить подсветку в диапазоне)
+     * @param {number} start — начало диапазона (selectionStart)
+     * @param {number} end — конец диапазона (selectionEnd)
+     * @param {string} [objectId] — если не задан, используется this.currentId
+     */
+    _addHighlight(color, start, end, objectId) {
+        const targetId = objectId || this.currentId;
+        if (!targetId) return;
+        const props = getObjectProperties(this.eventBus, targetId);
+
+        let contentLength = 0;
+        const editor = document.querySelector('.moodboard-text-input');
+        if (editor) {
+            contentLength = editor.value.length;
+        } else {
+            contentLength = (props?.content ?? '').length;
+        }
+
+        const safeEnd = Math.min(end, contentLength);
+        const safeStart = Math.min(start, safeEnd);
+        if (safeStart >= safeEnd) return;
+
+        const oldHighlights = Array.isArray(props?.highlights) ? props.highlights : [];
+        const filtered = oldHighlights.filter(h => h.end <= safeStart || h.start >= safeEnd);
+        const newHighlights = color === 'transparent'
+            ? filtered
+            : [...filtered, { start: safeStart, end: safeEnd, color }]
+                .sort((a, b) => a.start - b.start);
+
+        // Если редактор открыт, синхронизируем его текущее значение в state вместе с
+        // подсветкой. Иначе при коммите UpdateContentCommand._applyContent вычисляет
+        // _adjustHighlights(oldText = stale initialContent, newText = editor.value) и
+        // сдвигает/удаляет только что добавленные диапазоны.
+        const propertiesUpdate = { highlights: newHighlights };
+        if (editor) {
+            propertiesUpdate.content = editor.value;
+        }
+
+        this.eventBus.emit(Events.Object.StateChanged, {
+            objectId: targetId,
+            updates: { properties: propertiesUpdate },
+        });
+        this._updateTextAppearance(targetId, { highlights: newHighlights });
+    }
+
     _updateTextAppearance(objectId, properties) {
         applyTextAppearanceToDom(objectId, properties);
         syncPixiTextProperties(this.eventBus, objectId, properties);

package/src/ui/handles/HandlesDomRenderer.js

@@ -1218,6 +1218,8 @@ export class HandlesDomRenderer {
         this.host.layer.innerHTML = '';
         const box = document.createElement('div');
         box.className = 'mb-handles-box';
+        box.id = `mb-handles-box-${id}`;
+        box.dataset.objectId = id;
 
         let rotation = options.rotation ?? 0;
         if (id !== '__group__') {

package/src/ui/handles/HandlesInteractionController.js

@@ -500,7 +500,17 @@ export class HandlesInteractionController {
             isNoteTarget = (mbType === 'note');
         }
 
+        let _edgeHasMoved = false;
+        const EDGE_DRAG_THRESHOLD = 4;
+
         const onMove = (ev) => {
+            if (!_edgeHasMoved) {
+                const dx = ev.clientX - startMouse.x;
+                const dy = ev.clientY - startMouse.y;
+                if (Math.hypot(dx, dy) > EDGE_DRAG_THRESHOLD) {
+                    _edgeHasMoved = true;
+                }
+            }
             const maintainAspectRatio = !!ev.shiftKey;
             if (isGroup && maintainAspectRatio !== previousMaintainAspectRatio) {
                 startCSS = this._readBoxCss(box);
@@ -657,6 +667,36 @@ export class HandlesInteractionController {
         const onUp = () => {
             document.removeEventListener('pointermove', onMove);
             document.removeEventListener('pointerup', onUp);
+
+            // Клик по рамке без перетаскивания на текстовом объекте → редактирование
+            if (!_edgeHasMoved && isTextTarget && !isGroup) {
+                const posData = { objectId: id, position: null };
+                this.host.eventBus.emit(Events.Tool.GetObjectPosition, posData);
+                const _pixiReq = { objectId: id, pixiObject: null };
+                this.host.eventBus.emit(Events.Tool.GetObjectPixi, _pixiReq);
+                const _textProps = _pixiReq.pixiObject?._mb?.properties || {};
+                this.host.eventBus.emit(Events.Tool.ObjectEdit, {
+                    id,
+                    type: 'text',
+                    position: posData.position,
+                    properties: {
+                        ..._textProps,
+                        content: _textProps.content || '',
+                    },
+                    caretClick: { clientX: e.clientX, clientY: e.clientY },
+                    create: false,
+                });
+                // Сбрасываем состояние resize без создания команды в истории
+                this.host.eventBus.emit(Events.Tool.ResizeEnd, {
+                    object: id,
+                    oldSize: { width: startWorld.width, height: startWorld.height },
+                    newSize: { width: startWorld.width, height: startWorld.height },
+                    oldPosition: { x: startWorld.x, y: startWorld.y },
+                    newPosition: { x: startWorld.x, y: startWorld.y },
+                });
+                return;
+            }
+
             const endCSS = {
                 left: parseFloat(box.style.left),
                 top: parseFloat(box.style.top),