@sequent-org/moodboard 1.2.119 → 1.3.0

package/src/ui/handles/HandlesPositioningService.js

@@ -0,0 +1,206 @@
+import * as PIXI from 'pixi.js';
+import { Events } from '../../core/events/Events.js';
+
+export class HandlesPositioningService {
+    constructor(host) {
+        this.host = host;
+    }
+
+    _rotatePoint(point, center, angleDegrees) {
+        const angleRad = angleDegrees * Math.PI / 180;
+        const cos = Math.cos(angleRad);
+        const sin = Math.sin(angleRad);
+        const dx = point.x - center.x;
+        const dy = point.y - center.y;
+        return {
+            x: center.x + dx * cos - dy * sin,
+            y: center.y + dx * sin + dy * cos,
+        };
+    }
+
+    _getWorldRectFromState(position, size, rotation = 0) {
+        if (!position || !size) return null;
+        const width = Math.max(1, size.width || 1);
+        const height = Math.max(1, size.height || 1);
+        if (Math.abs(rotation || 0) < 0.001) {
+            return {
+                x: position.x,
+                y: position.y,
+                width,
+                height,
+            };
+        }
+
+        const center = {
+            x: position.x + width / 2,
+            y: position.y + height / 2,
+        };
+        const corners = [
+            { x: position.x, y: position.y },
+            { x: position.x + width, y: position.y },
+            { x: position.x + width, y: position.y + height },
+            { x: position.x, y: position.y + height },
+        ].map((point) => this._rotatePoint(point, center, rotation));
+
+        const xs = corners.map((point) => point.x);
+        const ys = corners.map((point) => point.y);
+        const minX = Math.min(...xs);
+        const maxX = Math.max(...xs);
+        const minY = Math.min(...ys);
+        const maxY = Math.max(...ys);
+        return {
+            x: minX,
+            y: minY,
+            width: Math.max(1, maxX - minX),
+            height: Math.max(1, maxY - minY),
+        };
+    }
+
+    toWorldScreenInverse(dx, dy) {
+        const world = this.host.core.pixi.worldLayer || this.host.core.pixi.app.stage;
+        const s = world?.scale?.x || 1;
+        return { dxWorld: dx / s, dyWorld: dy / s };
+    }
+
+    getViewportOffsets() {
+        const containerRect = this.host.container.getBoundingClientRect();
+        const view = this.host.core.pixi.app.view;
+        const viewRect = view.getBoundingClientRect();
+        return {
+            offsetLeft: viewRect.left - containerRect.left,
+            offsetTop: viewRect.top - containerRect.top,
+        };
+    }
+
+    getWorldTransform() {
+        const world = this.host.core.pixi.worldLayer || this.host.core.pixi.app.stage;
+        const s = world?.scale?.x || 1;
+        const tx = world?.x || 0;
+        const ty = world?.y || 0;
+        const rendererRes = (this.host.core.pixi.app.renderer?.resolution) || 1;
+        return { world, s, tx, ty, rendererRes };
+    }
+
+    worldBoundsToCssRect(worldBounds) {
+        const { world } = this.getWorldTransform();
+        const { offsetLeft, offsetTop } = this.getViewportOffsets();
+        const tl = world.toGlobal(new PIXI.Point(worldBounds.x, worldBounds.y));
+        const br = world.toGlobal(new PIXI.Point(worldBounds.x + worldBounds.width, worldBounds.y + worldBounds.height));
+        return {
+            left: offsetLeft + tl.x,
+            top: offsetTop + tl.y,
+            width: Math.max(1, br.x - tl.x),
+            height: Math.max(1, br.y - tl.y),
+            offsetLeft,
+            offsetTop,
+        };
+    }
+
+    cssRectToWorldRect(cssRect, offsets = null) {
+        const { s, tx, ty, rendererRes } = this.getWorldTransform();
+        const { offsetLeft, offsetTop } = offsets || this.getViewportOffsets();
+        const screenX = cssRect.left - offsetLeft;
+        const screenY = cssRect.top - offsetTop;
+        return {
+            x: ((screenX * rendererRes) - tx) / s,
+            y: ((screenY * rendererRes) - ty) / s,
+            width: (cssRect.width * rendererRes) / s,
+            height: (cssRect.height * rendererRes) / s,
+        };
+    }
+
+    getSingleSelectionWorldBounds(id, pixi) {
+        const positionData = { objectId: id, position: null };
+        const sizeData = { objectId: id, size: null };
+        this.host.eventBus.emit(Events.Tool.GetObjectPosition, positionData);
+        this.host.eventBus.emit(Events.Tool.GetObjectSize, sizeData);
+
+        if (positionData.position && sizeData.size) {
+            return {
+                x: positionData.position.x,
+                y: positionData.position.y,
+                width: sizeData.size.width,
+                height: sizeData.size.height,
+            };
+        }
+
+        const { world } = this.getWorldTransform();
+        const b = pixi.getBounds();
+        const tl = world.toLocal(new PIXI.Point(b.x, b.y));
+        const br = world.toLocal(new PIXI.Point(b.x + b.width, b.y + b.height));
+        const wx = Math.min(tl.x, br.x);
+        const wy = Math.min(tl.y, br.y);
+        const ww = Math.max(1, Math.abs(br.x - tl.x));
+        const wh = Math.max(1, Math.abs(br.y - tl.y));
+        return { x: wx, y: wy, width: ww, height: wh };
+    }
+
+    getGroupSelectionWorldBounds(ids) {
+        const { world } = this.getWorldTransform();
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+
+        ids.forEach((id) => {
+            const positionData = { objectId: id, position: null };
+            const sizeData = { objectId: id, size: null };
+            const rotationData = { objectId: id, rotation: 0 };
+            this.host.eventBus.emit(Events.Tool.GetObjectPosition, positionData);
+            this.host.eventBus.emit(Events.Tool.GetObjectSize, sizeData);
+            this.host.eventBus.emit(Events.Tool.GetObjectRotation, rotationData);
+
+            const rectFromState = this._getWorldRectFromState(
+                positionData.position,
+                sizeData.size,
+                rotationData.rotation || 0
+            );
+
+            let x0;
+            let y0;
+            let x1;
+            let y1;
+
+            if (rectFromState) {
+                x0 = rectFromState.x;
+                y0 = rectFromState.y;
+                x1 = rectFromState.x + rectFromState.width;
+                y1 = rectFromState.y + rectFromState.height;
+            } else {
+                const p = this.host.core.pixi.objects.get(id);
+                if (!p) return;
+                const b = p.getBounds();
+                const tl = world.toLocal(new PIXI.Point(b.x, b.y));
+                const br = world.toLocal(new PIXI.Point(b.x + b.width, b.y + b.height));
+                x0 = Math.min(tl.x, br.x);
+                y0 = Math.min(tl.y, br.y);
+                x1 = Math.max(tl.x, br.x);
+                y1 = Math.max(tl.y, br.y);
+            }
+
+            minX = Math.min(minX, x0);
+            minY = Math.min(minY, y0);
+            maxX = Math.max(maxX, x1);
+            maxY = Math.max(maxY, y1);
+        });
+
+        if (!isFinite(minX)) return null;
+        return {
+            x: minX,
+            y: minY,
+            width: Math.max(1, maxX - minX),
+            height: Math.max(1, maxY - minY),
+        };
+    }
+
+    cssPointToWorld(centerX, centerY) {
+        const { s, tx, ty, rendererRes } = this.getWorldTransform();
+        const { offsetLeft, offsetTop } = this.getViewportOffsets();
+        const screenX = centerX - offsetLeft;
+        const screenY = centerY - offsetTop;
+        return {
+            x: ((screenX * rendererRes) - tx) / s,
+            y: ((screenY * rendererRes) - ty) / s,
+        };
+    }
+}

package/src/ui/handles/SingleSelectionHandlesController.js

@@ -0,0 +1,22 @@
+export class SingleSelectionHandlesController {
+    constructor(host) {
+        this.host = host;
+    }
+
+    renderForSelection(id) {
+        const pixi = this.host.core.pixi.objects.get(id);
+        if (!pixi) {
+            this.host.hide();
+            return;
+        }
+
+        const mb = pixi._mb || {};
+        if (mb.type === 'comment') {
+            this.host.hide();
+            return;
+        }
+
+        const worldBounds = this.host.positioningService.getSingleSelectionWorldBounds(id, pixi);
+        this.host._showBounds(worldBounds, id);
+    }
+}

package/src/ui/styles/toolbar.css

@@ -49,6 +49,7 @@
 .moodboard-toolbar__button--text-add svg { height: 16px; width: auto; }
 .moodboard-toolbar__button--text-add:hover svg { transform: none; }
 .moodboard-toolbar__button:hover svg { transform: none; }
+.moodboard-toolbar__button--image2 svg { color: #7c3aed; }
 
 /* Hover palette for all toolbar buttons */
 .moodboard-toolbar__button--select:hover,
@@ -56,6 +57,7 @@
 .moodboard-toolbar__button--text-add:hover,
 .moodboard-toolbar__button--note:hover,
 .moodboard-toolbar__button--image:hover,
+.moodboard-toolbar__button--image2:hover,
 .moodboard-toolbar__button--shapes:hover,
 .moodboard-toolbar__button--pencil:hover,
 .moodboard-toolbar__button--comments:hover,

package/src/ui/styles/workspace.css

@@ -244,9 +244,10 @@
 
 .mb-handles-box {
     position: absolute;
-    border: 1px solid #1DE9B6;
+    outline: 2px solid #80D8FF;
+    outline-offset: 0;
     border-radius: 3px;
-    box-sizing: content-box;
+    box-sizing: border-box;
     pointer-events: none;
     transform-origin: center center;
 }
@@ -255,8 +256,8 @@
     position: absolute;
     width: 12px;
     height: 12px;
-    background: #1DE9B6;
-    border: 2px solid #1DE9B6;
+    background: #80D8FF;
+    border: 2px solid #80D8FF;
     border-radius: 50%;
     box-sizing: border-box;
     pointer-events: auto;
@@ -645,8 +646,14 @@
     gap: 8px;
 }
 
-/* Draw popup layout */
-.moodboard-draw__grid { display: grid; gap: 8px; }
+/* Draw popup layout: 2×3 grid, верхний и нижний ряд выровнены по колонкам */
+.moodboard-draw__grid {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    gap: 8px;
+}
+.moodboard-draw__grid > .moodboard-draw__row { display: contents; }
+.moodboard-draw__placeholder { min-width: 30px; min-height: 30px; }
 .moodboard-emoji__section { margin-bottom: 8px; }
 .moodboard-emoji__title {
     font-size: 12px;

package/src/ui/text-properties/TextPropertiesPanelBindings.js

@@ -0,0 +1,92 @@
+function hidePresetTicks(buttons) {
+    buttons.forEach((button) => {
+        const tick = button.querySelector('i');
+        if (tick) {
+            tick.style.display = 'none';
+        }
+    });
+}
+
+export function bindTextPropertiesPanelControls(panel) {
+    if (panel._bindingsAttached) {
+        return;
+    }
+
+    panel.fontSelect.addEventListener('change', (event) => {
+        panel._changeFontFamily(event.target.value);
+    });
+
+    panel.fontSizeSelect.addEventListener('change', (event) => {
+        panel._changeFontSize(parseInt(event.target.value, 10));
+    });
+
+    panel.currentColorButton.addEventListener('click', (event) => {
+        event.stopPropagation();
+        panel._toggleColorDropdown();
+    });
+
+    panel._colorPresetButtons.forEach((button) => {
+        button.addEventListener('click', () => {
+            hidePresetTicks(panel._colorPresetButtons);
+            const tick = button.querySelector('i');
+            if (tick) {
+                tick.style.display = 'block';
+            }
+            panel._selectColor(button.dataset.colorValue);
+        });
+    });
+
+    panel.colorInput.addEventListener('change', (event) => {
+        panel._selectColor(event.target.value);
+    });
+
+    panel._onColorDocumentClick = (event) => {
+        if (!panel._colorSelectorContainer || !event.target || !panel._colorSelectorContainer.contains(event.target)) {
+            panel._hideColorDropdown();
+        }
+    };
+    document.addEventListener('click', panel._onColorDocumentClick);
+
+    panel.currentBgColorButton.addEventListener('click', (event) => {
+        event.stopPropagation();
+        panel._toggleBgColorDropdown();
+    });
+
+    panel._bgPresetButtons.forEach((button) => {
+        button.addEventListener('click', () => {
+            hidePresetTicks(panel._bgPresetButtons);
+            const tick = button.querySelector('i');
+            if (tick) {
+                tick.style.display = 'block';
+            }
+            panel._selectBgColor(button.dataset.colorValue);
+        });
+    });
+
+    panel.bgColorInput.addEventListener('change', (event) => {
+        panel._selectBgColor(event.target.value);
+    });
+
+    panel._onBgDocumentClick = (event) => {
+        if (!panel._bgSelectorContainer || !event.target || !panel._bgSelectorContainer.contains(event.target)) {
+            panel._hideBgColorDropdown();
+        }
+    };
+    document.addEventListener('click', panel._onBgDocumentClick);
+
+    panel._bindingsAttached = true;
+}
+
+export function unbindTextPropertiesPanelControls(panel) {
+    if (panel._onColorDocumentClick) {
+        document.removeEventListener('click', panel._onColorDocumentClick);
+        panel._onColorDocumentClick = null;
+    }
+
+    if (panel._onBgDocumentClick) {
+        document.removeEventListener('click', panel._onBgDocumentClick);
+        panel._onBgDocumentClick = null;
+    }
+
+    panel._bindingsAttached = false;
+}

package/src/ui/text-properties/TextPropertiesPanelEventBridge.js

@@ -0,0 +1,77 @@
+import { Events } from '../../core/events/Events.js';
+
+export function attachTextPropertiesPanelEventBridge(panel) {
+    if (panel._eventBridgeAttached) {
+        return;
+    }
+
+    panel._eventBridgeHandlers = {
+        onSelectionAdd: () => panel.updateFromSelection(),
+        onSelectionRemove: () => panel.updateFromSelection(),
+        onSelectionClear: () => panel.hide(),
+        onDragUpdate: () => panel.reposition(),
+        onGroupDragUpdate: () => panel.reposition(),
+        onResizeUpdate: () => panel.reposition(),
+        onRotateUpdate: () => panel.reposition(),
+        onZoomPercent: () => panel.reposition(),
+        onPanUpdate: () => panel.reposition(),
+        onDeleted: ({ objectId }) => {
+            if (panel.currentId && objectId === panel.currentId) {
+                panel.hide();
+            }
+        },
+        onTextEditStart: () => {
+            panel.isTextEditing = true;
+            panel.hide();
+        },
+        onTextEditEnd: () => {
+            panel.isTextEditing = false;
+            setTimeout(() => panel.updateFromSelection(), 100);
+        },
+        onStateChanged: ({ objectId }) => {
+            if (panel.currentId && objectId === panel.currentId && panel.panel && panel.panel.style.display !== 'none') {
+                panel._updateControlsFromObject();
+            }
+        },
+    };
+
+    panel.eventBus.on(Events.Tool.SelectionAdd, panel._eventBridgeHandlers.onSelectionAdd);
+    panel.eventBus.on(Events.Tool.SelectionRemove, panel._eventBridgeHandlers.onSelectionRemove);
+    panel.eventBus.on(Events.Tool.SelectionClear, panel._eventBridgeHandlers.onSelectionClear);
+    panel.eventBus.on(Events.Tool.DragUpdate, panel._eventBridgeHandlers.onDragUpdate);
+    panel.eventBus.on(Events.Tool.GroupDragUpdate, panel._eventBridgeHandlers.onGroupDragUpdate);
+    panel.eventBus.on(Events.Tool.ResizeUpdate, panel._eventBridgeHandlers.onResizeUpdate);
+    panel.eventBus.on(Events.Tool.RotateUpdate, panel._eventBridgeHandlers.onRotateUpdate);
+    panel.eventBus.on(Events.UI.ZoomPercent, panel._eventBridgeHandlers.onZoomPercent);
+    panel.eventBus.on(Events.Tool.PanUpdate, panel._eventBridgeHandlers.onPanUpdate);
+    panel.eventBus.on(Events.Object.Deleted, panel._eventBridgeHandlers.onDeleted);
+    panel.eventBus.on(Events.UI.TextEditStart, panel._eventBridgeHandlers.onTextEditStart);
+    panel.eventBus.on(Events.UI.TextEditEnd, panel._eventBridgeHandlers.onTextEditEnd);
+    panel.eventBus.on(Events.Object.StateChanged, panel._eventBridgeHandlers.onStateChanged);
+
+    panel._eventBridgeAttached = true;
+}
+
+export function detachTextPropertiesPanelEventBridge(panel) {
+    if (!panel._eventBridgeAttached || !panel._eventBridgeHandlers || !panel.eventBus?.off) {
+        panel._eventBridgeAttached = false;
+        return;
+    }
+
+    panel.eventBus.off(Events.Tool.SelectionAdd, panel._eventBridgeHandlers.onSelectionAdd);
+    panel.eventBus.off(Events.Tool.SelectionRemove, panel._eventBridgeHandlers.onSelectionRemove);
+    panel.eventBus.off(Events.Tool.SelectionClear, panel._eventBridgeHandlers.onSelectionClear);
+    panel.eventBus.off(Events.Tool.DragUpdate, panel._eventBridgeHandlers.onDragUpdate);
+    panel.eventBus.off(Events.Tool.GroupDragUpdate, panel._eventBridgeHandlers.onGroupDragUpdate);
+    panel.eventBus.off(Events.Tool.ResizeUpdate, panel._eventBridgeHandlers.onResizeUpdate);
+    panel.eventBus.off(Events.Tool.RotateUpdate, panel._eventBridgeHandlers.onRotateUpdate);
+    panel.eventBus.off(Events.UI.ZoomPercent, panel._eventBridgeHandlers.onZoomPercent);
+    panel.eventBus.off(Events.Tool.PanUpdate, panel._eventBridgeHandlers.onPanUpdate);
+    panel.eventBus.off(Events.Object.Deleted, panel._eventBridgeHandlers.onDeleted);
+    panel.eventBus.off(Events.UI.TextEditStart, panel._eventBridgeHandlers.onTextEditStart);
+    panel.eventBus.off(Events.UI.TextEditEnd, panel._eventBridgeHandlers.onTextEditEnd);
+    panel.eventBus.off(Events.Object.StateChanged, panel._eventBridgeHandlers.onStateChanged);
+
+    panel._eventBridgeHandlers = null;
+    panel._eventBridgeAttached = false;
+}

package/src/ui/text-properties/TextPropertiesPanelMapper.js

@@ -0,0 +1,173 @@
+import { Events } from '../../core/events/Events.js';
+
+export const FONT_OPTIONS = [
+    { value: 'Roboto, Arial, sans-serif', name: 'Roboto' },
+    { value: 'Oswald, Arial, sans-serif', name: 'Oswald' },
+    { value: '"Playfair Display", Georgia, serif', name: 'Playfair Display' },
+    { value: '"Roboto Slab", Georgia, serif', name: 'Roboto Slab' },
+    { value: '"Noto Serif", Georgia, serif', name: 'Noto Serif' },
+    { value: 'Lobster, "Comic Sans MS", cursive', name: 'Lobster' },
+    { value: 'Caveat, "Comic Sans MS", cursive', name: 'Caveat' },
+    { value: '"Rubik Mono One", "Courier New", monospace', name: 'Rubik Mono One' },
+    { value: '"Great Vibes", "Comic Sans MS", cursive', name: 'Great Vibes' },
+    { value: '"Amatic SC", "Comic Sans MS", cursive', name: 'Amatic SC' },
+    { value: '"Poiret One", Arial, sans-serif', name: 'Poiret One' },
+    { value: 'Pacifico, "Comic Sans MS", cursive', name: 'Pacifico' },
+];
+
+export const FONT_SIZE_OPTIONS = [8, 10, 12, 14, 16, 18, 20, 24, 28, 32, 36, 48, 60, 72];
+
+export const TEXT_COLOR_PRESETS = [
+    { color: '#000000', name: '#000000' },
+    { color: '#404040', name: '#404040' },
+    { color: '#999999', name: '#999999' },
+    { color: '#FF2D55', name: '#FF2D55' },
+    { color: '#CB30E0', name: '#CB30E0' },
+    { color: '#6155F5', name: '#6155F5' },
+    { color: '#00C0E8', name: '#00C0E8' },
+    { color: '#34C759', name: '#34C759' },
+    { color: '#FF8D28', name: '#FF8D28' },
+    { color: '#FFCC00', name: '#FFCC00' },
+];
+
+export const BACKGROUND_COLOR_PRESETS = [
+    { color: 'transparent', name: 'Без выделения' },
+    { color: '#ffff99', name: 'Желтый' },
+    { color: '#ffcc99', name: 'Оранжевый' },
+    { color: '#ff9999', name: 'Розовый' },
+    { color: '#ccffcc', name: 'Зеленый' },
+    { color: '#99ccff', name: 'Голубой' },
+    { color: '#cc99ff', name: 'Фиолетовый' },
+    { color: '#f0f0f0', name: 'Светло-серый' },
+    { color: '#d0d0d0', name: 'Серый' },
+    { color: '#ffffff', name: 'Белый' },
+    { color: '#000000', name: 'Черный' },
+    { color: '#333333', name: 'Темно-серый' },
+];
+
+export function getSelectedTextObjectId(core) {
+    const ids = core?.selectTool ? Array.from(core.selectTool.selectedObjects || []) : [];
+    if (!ids || ids.length !== 1) {
+        return null;
+    }
+
+    const id = ids[0];
+    const pixi = core?.pixi?.objects?.get ? core.pixi.objects.get(id) : null;
+    const mb = pixi?._mb || {};
+
+    if (mb.type !== 'text') {
+        return null;
+    }
+
+    return id;
+}
+
+export function getPixiObject(eventBus, objectId) {
+    if (!objectId) {
+        return null;
+    }
+
+    const pixiData = { objectId, pixiObject: null };
+    eventBus.emit(Events.Tool.GetObjectPixi, pixiData);
+    return pixiData.pixiObject;
+}
+
+export function getObjectProperties(eventBus, objectId) {
+    const pixiObject = getPixiObject(eventBus, objectId);
+    if (pixiObject && pixiObject._mb && pixiObject._mb.properties) {
+        return pixiObject._mb.properties;
+    }
+    return null;
+}
+
+export function getControlValuesFromProperties(properties) {
+    return {
+        fontFamily: properties.fontFamily || 'Roboto, Arial, sans-serif',
+        fontSize: String(properties.fontSize || 18),
+        color: properties.color || '#000000',
+        backgroundColor: properties.backgroundColor !== undefined ? properties.backgroundColor : 'transparent',
+    };
+}
+
+export function getFallbackControlValues() {
+    return {
+        fontFamily: 'Arial, sans-serif',
+        fontSize: '18',
+        color: '#000000',
+        backgroundColor: 'transparent',
+    };
+}
+
+export function buildFontFamilyUpdate(fontFamily) {
+    return {
+        properties: { fontFamily },
+    };
+}
+
+export function buildFontSizeUpdate(fontSize) {
+    return {
+        fontSize,
+    };
+}
+
+export function buildTextColorUpdate(color) {
+    return {
+        color,
+    };
+}
+
+export function buildBackgroundColorUpdate(backgroundColor) {
+    return {
+        backgroundColor,
+    };
+}
+
+export function applyTextAppearanceToDom(objectId, properties) {
+    const htmlElement = document.querySelector(`[data-id="${objectId}"]`);
+    if (!htmlElement) {
+        return;
+    }
+
+    if (properties.fontFamily) {
+        htmlElement.style.fontFamily = properties.fontFamily;
+    }
+    if (properties.fontSize) {
+        htmlElement.style.fontSize = `${properties.fontSize}px`;
+    }
+    if (properties.color) {
+        htmlElement.style.color = properties.color;
+    }
+    if (properties.backgroundColor !== undefined) {
+        if (properties.backgroundColor === 'transparent') {
+            htmlElement.style.backgroundColor = '';
+        } else {
+            htmlElement.style.backgroundColor = properties.backgroundColor;
+        }
+    }
+}
+
+export function syncPixiTextProperties(eventBus, objectId, properties) {
+    const pixiObject = getPixiObject(eventBus, objectId);
+    if (!pixiObject || !pixiObject._mb) {
+        return;
+    }
+
+    if (!pixiObject._mb.properties) {
+        pixiObject._mb.properties = {};
+    }
+
+    Object.assign(pixiObject._mb.properties, properties);
+}
+
+export function getObjectGeometry(eventBus, objectId) {
+    const posData = { objectId, position: null };
+    const sizeData = { objectId, size: null };
+
+    eventBus.emit(Events.Tool.GetObjectPosition, posData);
+    eventBus.emit(Events.Tool.GetObjectSize, sizeData);
+
+    return {
+        position: posData.position,
+        size: sizeData.size,
+    };
+}