@sequent-org/moodboard 1.2.119 → 1.3.0

package/src/tools/object-tools/selection/SelectionStateController.js

@@ -0,0 +1,91 @@
+import { Events } from '../../../core/events/Events.js';
+
+export function addToSelection(object) {
+    this.selection.add(object);
+    this.emit(Events.Tool.SelectionAdd, { object });
+    this.updateResizeHandles();
+}
+
+export function removeFromSelection(object) {
+    this.selection.remove(object);
+    this.emit(Events.Tool.SelectionRemove, { object });
+    this.updateResizeHandles();
+}
+
+export function clearSelection() {
+    // Проверяем, что инструмент не уничтожен
+    if (this.destroyed) {
+        return;
+    }
+
+    const objects = this.selection.toArray();
+    this.selection.clear();
+    this.emit(Events.Tool.SelectionClear, { objects });
+    this.updateResizeHandles();
+}
+
+export function selectAll() {
+    // TODO: Выделить все объекты на доске
+    this.emit(Events.Tool.SelectionAll);
+}
+
+export function deleteSelectedObjects() {
+    const objects = this.selection.toArray();
+    this.clearSelection();
+    this.emit(Events.Tool.ObjectsDelete, { objects });
+}
+
+export function editObject(object) {
+    this.emit(Events.Tool.ObjectEdit, { object });
+}
+
+export function getSelection() {
+    return this.selection.toArray();
+}
+
+export function hasSelection() {
+    return this.selection.size() > 0;
+}
+
+export function setSelection(objectIds) {
+    const prev = this.selection.toArray();
+    this.selection.clear();
+    this.selection.addMany(objectIds);
+    // Эмитим события для совместимости
+    if (prev.length > 0) {
+        this.emit(Events.Tool.SelectionClear, { objects: prev });
+    }
+    for (const id of objectIds) {
+        this.emit(Events.Tool.SelectionAdd, { object: id });
+    }
+    this.updateResizeHandles();
+}
+
+export function updateResizeHandles() {
+    // Проверяем, что инструмент не уничтожен
+    if (this.destroyed) {
+        return;
+    }
+
+    // Используем HTML-ручки (HtmlHandlesLayer). Прячем Pixi-ручки и групповые графики.
+    try {
+        if (this.resizeHandles && typeof this.resizeHandles.hideHandles === 'function') {
+            this.resizeHandles.hideHandles();
+        }
+        const stage = this.app?.stage;
+        const world = stage?.getChildByName && stage.getChildByName('worldLayer');
+        const rh = world && world.getChildByName && world.getChildByName('resize-handles');
+        if (rh) rh.visible = false;
+        const gb = stage && stage.getChildByName && stage.getChildByName('group-bounds');
+        if (gb) gb.visible = false;
+    } catch (_) {
+        // noop
+    }
+}
+
+export function onActivateSelection() {
+    // Подписка безопасна: EventBus простая шина, а вызов синхронный
+    this.eventBus.on(Events.Tool.GetSelection, (data) => {
+        data.selection = this.getSelection();
+    });
+}

package/src/tools/object-tools/selection/TextEditorDomFactory.js

@@ -0,0 +1,65 @@
+export function createTextEditorWrapper() {
+    const wrapper = document.createElement('div');
+    wrapper.className = 'moodboard-text-editor';
+    return wrapper;
+}
+
+export function createTextEditorTextarea(content) {
+    const textarea = document.createElement('textarea');
+    textarea.className = 'moodboard-text-input';
+    textarea.value = content || '';
+    textarea.placeholder = 'Напишите что-нибудь';
+    return textarea;
+}
+
+export function computeTextEditorLineHeightPx(fontSizePx) {
+    if (fontSizePx <= 12) return Math.round(fontSizePx * 1.40);
+    if (fontSizePx <= 18) return Math.round(fontSizePx * 1.34);
+    if (fontSizePx <= 36) return Math.round(fontSizePx * 1.26);
+    if (fontSizePx <= 48) return Math.round(fontSizePx * 1.24);
+    if (fontSizePx <= 72) return Math.round(fontSizePx * 1.22);
+    if (fontSizePx <= 96) return Math.round(fontSizePx * 1.20);
+    return Math.round(fontSizePx * 1.18);
+}
+
+export function applyInitialTextEditorTextareaStyles(textarea, { effectiveFontPx, lineHeightPx }) {
+    textarea.style.fontSize = `${effectiveFontPx}px`;
+    textarea.style.lineHeight = `${lineHeightPx}px`;
+
+    const initialHeightPx = Math.max(1, lineHeightPx);
+    textarea.style.minHeight = `${initialHeightPx}px`;
+    textarea.style.height = `${initialHeightPx}px`;
+    textarea.setAttribute('rows', '1');
+    textarea.style.overflowY = 'hidden';
+    textarea.style.whiteSpace = 'pre-wrap';
+    textarea.style.wordBreak = 'break-word';
+    textarea.style.letterSpacing = '0px';
+    textarea.style.fontKerning = 'normal';
+}
+
+export function measureTextEditorPlaceholderWidth(textarea, placeholder = 'Напишите что-нибудь') {
+    const measureEl = document.createElement('span');
+    measureEl.style.position = 'absolute';
+    measureEl.style.visibility = 'hidden';
+    measureEl.style.whiteSpace = 'pre';
+    measureEl.style.fontFamily = textarea.style.fontFamily;
+    measureEl.style.fontSize = textarea.style.fontSize;
+    measureEl.textContent = placeholder;
+    document.body.appendChild(measureEl);
+
+    const width = Math.ceil(measureEl.getBoundingClientRect().width);
+    measureEl.remove();
+    return width;
+}
+
+export function attachTextEditorPlaceholderStyle(textarea, { effectiveFontPx, isNote }) {
+    const uid = 'mbti-' + Math.random().toString(36).slice(2);
+    textarea.classList.add(uid);
+
+    const styleEl = document.createElement('style');
+    const placeholderOpacity = isNote ? '0.4' : '0.6';
+    styleEl.textContent = `.${uid}::placeholder{font-size:${effectiveFontPx}px;opacity:${placeholderOpacity};line-height:${computeTextEditorLineHeightPx(effectiveFontPx)}px;white-space:nowrap;}`;
+    document.head.appendChild(styleEl);
+
+    return styleEl;
+}

package/src/tools/object-tools/selection/TextEditorInteractionController.js

@@ -0,0 +1,266 @@
+import { Events } from '../../../core/events/Events.js';
+import { alignStaticTextToEditorCssPosition } from './TextEditorPositioningService.js';
+import {
+    cleanupActiveTextEditor,
+    showNotePixiText,
+    showStaticTextAfterEditing,
+    updateGlobalTextEditorHandlesLayer,
+} from './TextEditorLifecycleRegistry.js';
+
+export function applyTextEditorCaretFromClick({ create, objectId, object, textarea }) {
+    try {
+        const click = (object && object.caretClick) ? object.caretClick : null;
+        if (!create && objectId && click && typeof window !== 'undefined') {
+            setTimeout(() => {
+                try {
+                    const el = window.moodboardHtmlTextLayer ? window.moodboardHtmlTextLayer.idToEl.get(objectId) : null;
+                    const fullText = (typeof textarea.value === 'string') ? textarea.value : '';
+                    if (!el || !fullText || !el.firstChild) return;
+                    const textNode = el.firstChild;
+                    const len = textNode.textContent.length;
+                    if (len === 0) {
+                        textarea.selectionStart = textarea.selectionEnd = 0;
+                        return;
+                    }
+                    const doc = el.ownerDocument || document;
+                    let bestIdx = 0;
+                    let bestDist = Infinity;
+                    for (let i = 0; i <= len; i++) {
+                        const range = doc.createRange();
+                        range.setStart(textNode, i);
+                        range.setEnd(textNode, i);
+                        const rects = range.getClientRects();
+                        const rect = rects && rects.length > 0 ? rects[0] : range.getBoundingClientRect();
+                        if (rect && isFinite(rect.left) && isFinite(rect.top)) {
+                            if (click.clientX >= rect.left && click.clientX <= rect.right &&
+                                click.clientY >= rect.top && click.clientY <= rect.bottom) {
+                                bestIdx = i;
+                                bestDist = 0;
+                                break;
+                            }
+                            const cx = Math.max(rect.left, Math.min(click.clientX, rect.right));
+                            const cy = Math.max(rect.top, Math.min(click.clientY, rect.bottom));
+                            const dx = click.clientX - cx;
+                            const dy = click.clientY - cy;
+                            const d2 = dx * dx + dy * dy;
+                            if (d2 < bestDist) {
+                                bestDist = d2;
+                                bestIdx = i;
+                            }
+                        }
+                    }
+                    const clamp = (v, a, b) => Math.max(a, Math.min(b, v));
+                    const caret = clamp(bestIdx, 0, fullText.length);
+                    textarea.selectionStart = textarea.selectionEnd = caret;
+                    if (typeof textarea.scrollTop === 'number') textarea.scrollTop = 0;
+                    console.log('🧭 Text caret set', { objectId, caret, len: fullText.length });
+                } catch (_) {}
+            }, 0);
+        }
+    } catch (_) {}
+}
+
+export function createTextEditorFinalize(controller, {
+    textarea,
+    wrapper,
+    view,
+    viewRes,
+    position,
+    fontSize,
+    objectId,
+    isNewCreation,
+    initialContent = '',
+}) {
+    return (commit) => {
+        if (controller.textEditor?._removeDomListeners) {
+            controller.textEditor._removeDomListeners();
+            controller.textEditor._removeDomListeners = null;
+        }
+
+        const value = textarea.value.trim();
+        const commitValue = commit && value.length > 0;
+
+        const currentObjectType = controller.textEditor.objectType;
+
+        if (objectId && (commitValue || !isNewCreation)) {
+            showStaticTextAfterEditing(controller, objectId);
+        }
+
+        if (objectId && (currentObjectType === 'text' || currentObjectType === 'simple-text')) {
+            try {
+                const worldLayerRef = controller.textEditor.world || (controller.app?.stage);
+                const scaleX = worldLayerRef?.scale?.x || 1;
+                const viewResLocal = (controller.app?.renderer?.resolution) || (view.width && view.clientWidth ? (view.width / view.clientWidth) : 1);
+                const wPx = Math.max(1, wrapper.offsetWidth);
+                const hPx = Math.max(1, wrapper.offsetHeight);
+                const newW = Math.max(1, Math.round(wPx * viewResLocal / scaleX));
+                const newH = Math.max(1, Math.round(hPx * viewResLocal / scaleX));
+                const sizeReq = { objectId, size: null };
+                controller.eventBus.emit(Events.Tool.GetObjectSize, sizeReq);
+                const oldSize = sizeReq.size || { width: newW, height: newH };
+                const posReq = { objectId, position: null };
+                controller.eventBus.emit(Events.Tool.GetObjectPosition, posReq);
+                const oldPos = posReq.position || { x: position.x, y: position.y };
+                const newSize = { width: newW, height: newH };
+                controller.eventBus.emit(Events.Tool.ResizeUpdate, { object: objectId, size: newSize, position: oldPos });
+                controller.eventBus.emit(Events.Tool.ResizeEnd, { object: objectId, oldSize, newSize, oldPosition: oldPos, newPosition: oldPos });
+            } catch (err) {
+                console.warn('⚠️ Не удалось применить размеры после редактирования текста:', err);
+            }
+        }
+
+        cleanupActiveTextEditor(controller, wrapper);
+        if (currentObjectType === 'note') {
+            controller.eventBus.emit(Events.UI.NoteEditEnd, { objectId: objectId || null });
+            showNotePixiText(controller, objectId);
+        } else {
+            controller.eventBus.emit(Events.UI.TextEditEnd, { objectId: objectId || null });
+        }
+
+        updateGlobalTextEditorHandlesLayer();
+
+        if (!commitValue) {
+            if (isNewCreation && objectId) {
+                controller.eventBus.emit(Events.Tool.ObjectsDelete, { objects: [objectId] });
+            }
+            return;
+        }
+
+        if (objectId == null) {
+            const objectType = currentObjectType || 'text';
+            const worldLayerRef = controller.textEditor.world || (controller.app?.stage);
+            const scaleX = worldLayerRef?.scale?.x || 1;
+            const wPx = Math.max(1, wrapper.offsetWidth);
+            const hPx = Math.max(1, wrapper.offsetHeight);
+            const wWorld = Math.max(1, Math.round(wPx * viewRes / scaleX));
+            const hWorld = Math.max(1, Math.round(hPx * viewRes / scaleX));
+            controller.eventBus.emit(Events.UI.ToolbarAction, {
+                type: objectType,
+                id: objectType,
+                position: { x: position.x, y: position.y },
+                properties: { content: value, fontSize, width: wWorld, height: hWorld },
+            });
+        } else {
+            if (isNewCreation) {
+                controller.eventBus.emit(Events.Tool.UpdateObjectContent, { objectId, content: value });
+                controller.eventBus.emit(Events.Object.StateChanged, {
+                    objectId,
+                    updates: { properties: { content: value } },
+                });
+            } else {
+                const oldContent = typeof initialContent === 'string' ? initialContent : '';
+                controller.eventBus.emit(Events.Object.ContentChange, {
+                    objectId,
+                    oldContent,
+                    newContent: value,
+                });
+            }
+        }
+    };
+}
+
+export function bindTextEditorInteractions(controller, {
+    textarea,
+    isNewCreation,
+    isNote,
+    autoSize,
+    updateNoteEditor,
+    finalize,
+}) {
+    const blurHandler = () => {
+        const value = (textarea.value || '').trim();
+        if (isNewCreation && value.length === 0) {
+            finalize(false);
+            return;
+        }
+        finalize(true);
+    };
+
+    const keydownHandler = (e) => {
+        if (e.key === 'Enter' && !e.shiftKey) {
+            e.preventDefault();
+            finalize(true);
+        } else if (e.key === 'Escape') {
+            e.preventDefault();
+            finalize(false);
+        }
+    };
+
+    const inputHandler = !isNote
+        ? autoSize
+        : () => { try { if (updateNoteEditor) updateNoteEditor(); } catch (_) {} };
+
+    textarea.addEventListener('blur', blurHandler);
+    textarea.addEventListener('keydown', keydownHandler);
+    textarea.addEventListener('input', inputHandler);
+
+    const removeDomListeners = () => {
+        textarea.removeEventListener('blur', blurHandler);
+        textarea.removeEventListener('keydown', keydownHandler);
+        textarea.removeEventListener('input', inputHandler);
+    };
+
+    if (controller.textEditor) {
+        controller.textEditor._removeDomListeners = removeDomListeners;
+    }
+}
+
+export function closeTextEditorFromState(controller, commit) {
+    const textarea = controller.textEditor.textarea;
+    if (!textarea) return;
+    const value = textarea.value.trim();
+    const commitValue = commit && value.length > 0;
+    const objectType = controller.textEditor.objectType || 'text';
+    const objectId = controller.textEditor.objectId;
+    const position = controller.textEditor.position;
+    const properties = controller.textEditor.properties;
+    const isNewCreation = controller.textEditor.isNewCreation;
+    const initialContent = controller.textEditor.initialContent ?? '';
+
+    if (objectId) {
+        if (typeof window !== 'undefined' && window.moodboardHtmlTextLayer) {
+            const el = window.moodboardHtmlTextLayer.idToEl.get(objectId);
+            if (el) {
+                controller.eventBus.emit(Events.Tool.ShowObjectText, { objectId });
+                alignStaticTextToEditorCssPosition({
+                    controller,
+                    objectId,
+                    worldLayerRef: controller.textEditor.world || (controller.app?.stage),
+                    view: controller.app?.view,
+                    cssLeft: controller.textEditor._cssLeftPx,
+                    cssTop: controller.textEditor._cssTopPx,
+                });
+            } else {
+                console.warn(`❌ SelectTool: HTML-элемент для объекта ${objectId} не найден, пропускаем ShowObjectText`);
+            }
+        } else {
+            controller.eventBus.emit(Events.Tool.ShowObjectText, { objectId });
+        }
+    }
+
+    textarea.remove();
+    controller.textEditor = { active: false, objectId: null, textarea: null, world: null, objectType: 'text' };
+    if (!commitValue) return;
+    if (objectId == null) {
+        controller.eventBus.emit(Events.UI.ToolbarAction, {
+            type: objectType,
+            id: objectType,
+            position: { x: position.x, y: position.y },
+            properties: { content: value, fontSize: properties.fontSize },
+        });
+    } else {
+        if (isNewCreation) {
+            controller.eventBus.emit(Events.Tool.UpdateObjectContent, { objectId, content: value });
+            controller.eventBus.emit(Events.Object.StateChanged, {
+                objectId,
+                updates: { properties: { content: value } },
+            });
+        } else {
+            controller.eventBus.emit(Events.Object.ContentChange, {
+                objectId,
+                oldContent: initialContent,
+                newContent: value,
+            });
+        }
+    }
+}

package/src/tools/object-tools/selection/TextEditorLifecycleRegistry.js

@@ -0,0 +1,90 @@
+import { Events } from '../../../core/events/Events.js';
+import { unregisterEditorListeners } from './InlineEditorListenersRegistry.js';
+
+export function hideGlobalTextEditorHandlesLayer() {
+    try {
+        if (typeof window !== 'undefined' && window.moodboardHtmlHandlesLayer) {
+            window.moodboardHtmlHandlesLayer.hide();
+        }
+    } catch (_) {}
+}
+
+export function updateGlobalTextEditorHandlesLayer() {
+    try {
+        if (typeof window !== 'undefined' && window.moodboardHtmlHandlesLayer) {
+            window.moodboardHtmlHandlesLayer.update();
+        }
+    } catch (_) {}
+}
+
+export function hideStaticTextDuringEditing(controller, objectId) {
+    if (!objectId) return;
+
+    if (typeof window !== 'undefined' && window.moodboardHtmlTextLayer) {
+        const el = window.moodboardHtmlTextLayer.idToEl.get(objectId);
+        if (el) {
+            controller.eventBus.emit(Events.Tool.HideObjectText, { objectId });
+        } else {
+            console.warn(`❌ SelectTool: HTML-элемент для объекта ${objectId} не найден, пропускаем HideObjectText`);
+        }
+    } else {
+        controller.eventBus.emit(Events.Tool.HideObjectText, { objectId });
+    }
+}
+
+export function showStaticTextAfterEditing(controller, objectId) {
+    if (!objectId) return;
+
+    if (typeof window !== 'undefined' && window.moodboardHtmlTextLayer) {
+        const el = window.moodboardHtmlTextLayer.idToEl.get(objectId);
+        if (el) {
+            controller.eventBus.emit(Events.Tool.ShowObjectText, { objectId });
+        } else {
+            console.warn(`❌ SelectTool: HTML-элемент для объекта ${objectId} не найден, пропускаем ShowObjectText`);
+        }
+    } else {
+        controller.eventBus.emit(Events.Tool.ShowObjectText, { objectId });
+    }
+}
+
+export function hideNotePixiText(controller, objectId) {
+    try {
+        const pixiReq = { objectId, pixiObject: null };
+        controller.eventBus.emit(Events.Tool.GetObjectPixi, pixiReq);
+        const inst = pixiReq.pixiObject && pixiReq.pixiObject._mb && pixiReq.pixiObject._mb.instance;
+        if (inst && typeof inst.hideText === 'function') {
+            inst.hideText();
+        }
+    } catch (_) {}
+}
+
+export function showNotePixiText(controller, objectId) {
+    try {
+        const pixiReq = { objectId, pixiObject: null };
+        controller.eventBus.emit(Events.Tool.GetObjectPixi, pixiReq);
+        const inst = pixiReq.pixiObject && pixiReq.pixiObject._mb && pixiReq.pixiObject._mb.instance;
+        if (inst && typeof inst.showText === 'function') {
+            inst.showText();
+        }
+    } catch (_) {}
+}
+
+export function cleanupActiveTextEditor(controller, wrapper) {
+    try {
+        if (controller.textEditor && Array.isArray(controller.textEditor._listeners)) {
+            unregisterEditorListeners(controller.eventBus, controller.textEditor._listeners);
+        }
+    } catch (_) {}
+
+    wrapper.remove();
+    controller.textEditor = {
+        active: false,
+        objectId: null,
+        textarea: null,
+        wrapper: null,
+        world: null,
+        position: null,
+        properties: null,
+        objectType: 'text',
+    };
+}

package/src/tools/object-tools/selection/TextEditorPositioningService.js

@@ -0,0 +1,158 @@
+import * as PIXI from 'pixi.js';
+import { Events } from '../../../core/events/Events.js';
+import { toScreenWithContainerOffset } from './InlineEditorPositioningService.js';
+
+export function createTextEditorToScreen(controller, view) {
+    return (wx, wy) => toScreenWithContainerOffset(
+        controller.textEditor.world || (controller.app?.stage),
+        view,
+        wx,
+        wy
+    );
+}
+
+export function positionRegularTextEditor({
+    create,
+    objectId,
+    screenPos,
+    textarea,
+    wrapper,
+}) {
+    let padTop = 0;
+    let padLeft = 0;
+    let lineHeightPx = 0;
+    try {
+        if (typeof window !== 'undefined' && window.getComputedStyle) {
+            const cs = window.getComputedStyle(textarea);
+            const pt = parseFloat(cs.paddingTop);
+            const pl = parseFloat(cs.paddingLeft);
+            const lh = parseFloat(cs.lineHeight);
+            if (isFinite(pt)) padTop = pt;
+            if (isFinite(pl)) padLeft = pl;
+            if (isFinite(lh)) lineHeightPx = lh;
+        }
+    } catch (_) {}
+
+    if (!isFinite(lineHeightPx) || lineHeightPx <= 0) {
+        try {
+            const rect = textarea.getBoundingClientRect && textarea.getBoundingClientRect();
+            if (rect && isFinite(rect.height)) lineHeightPx = rect.height;
+        } catch (_) {}
+    }
+
+    let baseLeftPx = screenPos.x;
+    let baseTopPx = screenPos.y;
+    try {
+        if (!create && objectId && typeof window !== 'undefined' && window.moodboardHtmlTextLayer) {
+            const el = window.moodboardHtmlTextLayer.idToEl.get(objectId);
+            if (el) {
+                const cssLeft = parseFloat(el.style.left || 'NaN');
+                const cssTop = parseFloat(el.style.top || 'NaN');
+                if (isFinite(cssLeft)) baseLeftPx = cssLeft;
+                if (isFinite(cssTop)) baseTopPx = cssTop;
+            }
+        }
+    } catch (_) {}
+
+    const leftPx = Math.round(baseLeftPx - padLeft);
+    const topPx = create
+        ? Math.round(baseTopPx - padTop - (lineHeightPx / 2))
+        : Math.round(baseTopPx - padTop);
+
+    wrapper.style.left = `${leftPx}px`;
+    wrapper.style.top = `${topPx}px`;
+
+    return {
+        leftPx,
+        topPx,
+        padTop,
+        padLeft,
+        lineHeightPx,
+        baseLeftPx,
+        baseTopPx,
+    };
+}
+
+export function syncCreatedTextEditorWorldPosition({
+    controller,
+    create,
+    objectId,
+    position,
+    leftPx,
+    topPx,
+    padTop,
+}) {
+    try {
+        if (create && objectId) {
+            const worldLayerRef = controller.textEditor.world || (controller.app?.stage);
+            const viewEl = controller.app?.view;
+            if (worldLayerRef && viewEl && viewEl.parentElement) {
+                const containerRect = viewEl.parentElement.getBoundingClientRect();
+                const viewRect = viewEl.getBoundingClientRect();
+                const offsetLeft = viewRect.left - containerRect.left;
+                const offsetTop = viewRect.top - containerRect.top;
+
+                const yCssStaticTop = Math.round(topPx + padTop);
+                const screenX = Math.round(leftPx - offsetLeft);
+                const screenY = Math.round(yCssStaticTop - offsetTop);
+                const globalPoint = new PIXI.Point(screenX, screenY);
+                const worldPoint = worldLayerRef.toLocal
+                    ? worldLayerRef.toLocal(globalPoint)
+                    : { x: position.x, y: position.y };
+                const newWorldPos = {
+                    x: Math.round(worldPoint.x),
+                    y: Math.round(worldPoint.y),
+                };
+
+                controller.eventBus.emit(Events.Object.StateChanged, {
+                    objectId,
+                    updates: { position: newWorldPos },
+                });
+
+                console.log('🧭 Text position sync', {
+                    objectId,
+                    newWorldPos,
+                    leftPx,
+                    topPx,
+                    yCssStaticTop,
+                    padTop,
+                    offsetLeft,
+                    offsetTop,
+                });
+            }
+        }
+    } catch (_) {}
+}
+
+export function alignStaticTextToEditorCssPosition({
+    controller,
+    objectId,
+    worldLayerRef,
+    view,
+    cssLeft,
+    cssTop,
+}) {
+    try {
+        if (view && view.parentElement && isFinite(cssLeft) && isFinite(cssTop) && worldLayerRef) {
+            setTimeout(() => {
+                try {
+                    const containerRect = view.parentElement.getBoundingClientRect();
+                    const viewRect = view.getBoundingClientRect();
+                    const offsetLeft = viewRect.left - containerRect.left;
+                    const offsetTop = viewRect.top - containerRect.top;
+                    const screenX = cssLeft - offsetLeft;
+                    const screenY = cssTop - offsetTop;
+                    const desiredWorld = worldLayerRef.toLocal(new PIXI.Point(screenX, screenY));
+                    const newPos = { x: Math.round(desiredWorld.x), y: Math.round(desiredWorld.y) };
+
+                    controller.eventBus.emit(Events.Object.StateChanged, {
+                        objectId,
+                        updates: { position: newPos },
+                    });
+
+                    console.log('🧭 Text post-show align', { objectId, cssLeft, cssTop, newPos });
+                } catch (_) {}
+            }, 0);
+        }
+    } catch (_) {}
+}