@sequent-org/moodboard 1.2.93 → 1.2.94

package/package.json

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

package/src/tools/object-tools/SelectTool.js

@@ -2829,72 +2829,79 @@ export class SelectTool extends BaseTool {
      * Получение коэффициента масштабирования браузера
      */
     _getBrowserZoomFactor() {
-        // Множественные методы определения масштаба браузера для надежности
-        let zoomFactors = [];
-        
-        try {
-            // Метод 1: Через window размеры
-            const outerInnerRatio = window.outerWidth / window.innerWidth;
-            if (isFinite(outerInnerRatio) && outerInnerRatio > 0.1 && outerInnerRatio < 10) {
-                zoomFactors.push({ method: 'outerInner', value: outerInnerRatio });
-            }
-        } catch (_) {}
-        
+        // Новый подход: через измерение canvas размеров
         try {
-            // Метод 2: Через visualViewport если доступно
-            if (window.visualViewport) {
-                const vpZoom = window.innerWidth / window.visualViewport.width;
-                if (isFinite(vpZoom) && vpZoom > 0.1 && vpZoom < 10) {
-                    zoomFactors.push({ method: 'visualViewport', value: vpZoom });
+            if (this.app && this.app.view) {
+                const canvas = this.app.view;
+                
+                // Получаем CSS размеры и реальные размеры canvas
+                const cssWidth = canvas.clientWidth;
+                const cssHeight = canvas.clientHeight;
+                const realWidth = canvas.width;
+                const realHeight = canvas.height;
+                
+                // Проверяем device pixel ratio
+                const dpr = window.devicePixelRatio || 1;
+                
+                // Вычисляем ожидаемые реальные размеры с учетом DPR
+                const expectedRealWidth = cssWidth * dpr;
+                const expectedRealHeight = cssHeight * dpr;
+                
+                // Если реальные размеры отличаются от ожидаемых, значит есть zoom
+                let zoomFactorW = 1.0;
+                let zoomFactorH = 1.0;
+                
+                if (expectedRealWidth > 0) {
+                    zoomFactorW = realWidth / expectedRealWidth;
+                }
+                if (expectedRealHeight > 0) {
+                    zoomFactorH = realHeight / expectedRealHeight;
+                }
+                
+                // Берем среднее значение или наиболее близкое к 1.0
+                const avgZoom = (zoomFactorW + zoomFactorH) / 2;
+                
+                console.log('🔍 Canvas zoom detection:', {
+                    css: { width: cssWidth, height: cssHeight },
+                    real: { width: realWidth, height: realHeight },
+                    dpr,
+                    expected: { width: expectedRealWidth, height: expectedRealHeight },
+                    zoom: { width: zoomFactorW, height: zoomFactorH, avg: avgZoom }
+                });
+                
+                // Если обнаружили разумное отклонение от 1.0, используем его
+                if (isFinite(avgZoom) && avgZoom > 0.1 && avgZoom < 10 && Math.abs(avgZoom - 1.0) > 0.01) {
+                    return avgZoom;
                 }
             }
         } catch (_) {}
         
+        // Fallback: простой метод через screen размеры
         try {
-            // Метод 3: Через тестовый элемент (проверяем разные единицы)
-            const testEl = document.createElement('div');
-            testEl.style.position = 'absolute';
-            testEl.style.left = '-9999px';
-            testEl.style.top = '-9999px';
-            testEl.style.width = '100px';
-            testEl.style.height = '100px';
-            testEl.style.visibility = 'hidden';
-            testEl.style.pointerEvents = 'none';
-            
-            document.body.appendChild(testEl);
-            
-            const rect = testEl.getBoundingClientRect();
-            const elemZoom = 100 / rect.width;
-            
-            document.body.removeChild(testEl);
+            // Сравниваем screen.width с window.innerWidth
+            const screenRatio = screen.width / window.innerWidth;
+            const dpr = window.devicePixelRatio || 1;
+            const expectedRatio = dpr;
             
-            if (isFinite(elemZoom) && elemZoom > 0.1 && elemZoom < 10) {
-                zoomFactors.push({ method: 'testElement', value: elemZoom });
+            if (Math.abs(screenRatio - expectedRatio) > 0.1) {
+                const zoomFactor = screenRatio / expectedRatio;
+                
+                console.log('🔍 Screen zoom detection:', {
+                    screen: { width: screen.width, height: screen.height },
+                    window: { innerWidth: window.innerWidth, innerHeight: window.innerHeight },
+                    screenRatio,
+                    expectedRatio,
+                    zoomFactor
+                });
+                
+                if (isFinite(zoomFactor) && zoomFactor > 0.1 && zoomFactor < 10) {
+                    return zoomFactor;
+                }
             }
         } catch (_) {}
         
-        // Логирование всех методов для диагностики
-        console.log('🔍 Zoom detection methods:', zoomFactors);
-        
-        // Выбираем наиболее подходящий результат
-        if (zoomFactors.length === 0) {
-            return 1.0; // Fallback
-        }
-        
-        // Если есть visualViewport, предпочитаем его
-        const vpMethod = zoomFactors.find(f => f.method === 'visualViewport');
-        if (vpMethod) {
-            return vpMethod.value;
-        }
-        
-        // Иначе берем outerInner как наиболее стабильный
-        const outerMethod = zoomFactors.find(f => f.method === 'outerInner');
-        if (outerMethod) {
-            return outerMethod.value;
-        }
-        
-        // Последний fallback - первый доступный метод
-        return zoomFactors[0].value;
+        console.log('🔍 Zoom detection: using fallback (no zoom correction)');
+        return 1.0; // Fallback: без коррекции
     }
 
 }

package/src/ui/HtmlTextLayer.js

@@ -376,69 +376,61 @@ export class HtmlTextLayer {
      * Получение коэффициента масштабирования браузера
      */
     _getBrowserZoomFactor() {
-        // Множественные методы определения масштаба браузера для надежности
-        let zoomFactors = [];
-        
-        try {
-            // Метод 1: Через window размеры
-            const outerInnerRatio = window.outerWidth / window.innerWidth;
-            if (isFinite(outerInnerRatio) && outerInnerRatio > 0.1 && outerInnerRatio < 10) {
-                zoomFactors.push({ method: 'outerInner', value: outerInnerRatio });
-            }
-        } catch (_) {}
-        
+        // Новый подход: через измерение canvas размеров
         try {
-            // Метод 2: Через visualViewport если доступно
-            if (window.visualViewport) {
-                const vpZoom = window.innerWidth / window.visualViewport.width;
-                if (isFinite(vpZoom) && vpZoom > 0.1 && vpZoom < 10) {
-                    zoomFactors.push({ method: 'visualViewport', value: vpZoom });
+            if (this.core && this.core.pixi && this.core.pixi.app && this.core.pixi.app.view) {
+                const canvas = this.core.pixi.app.view;
+                
+                // Получаем CSS размеры и реальные размеры canvas
+                const cssWidth = canvas.clientWidth;
+                const cssHeight = canvas.clientHeight;
+                const realWidth = canvas.width;
+                const realHeight = canvas.height;
+                
+                // Проверяем device pixel ratio
+                const dpr = window.devicePixelRatio || 1;
+                
+                // Вычисляем ожидаемые реальные размеры с учетом DPR
+                const expectedRealWidth = cssWidth * dpr;
+                const expectedRealHeight = cssHeight * dpr;
+                
+                // Если реальные размеры отличаются от ожидаемых, значит есть zoom
+                let zoomFactorW = 1.0;
+                let zoomFactorH = 1.0;
+                
+                if (expectedRealWidth > 0) {
+                    zoomFactorW = realWidth / expectedRealWidth;
+                }
+                if (expectedRealHeight > 0) {
+                    zoomFactorH = realHeight / expectedRealHeight;
+                }
+                
+                // Берем среднее значение
+                const avgZoom = (zoomFactorW + zoomFactorH) / 2;
+                
+                // Если обнаружили разумное отклонение от 1.0, используем его
+                if (isFinite(avgZoom) && avgZoom > 0.1 && avgZoom < 10 && Math.abs(avgZoom - 1.0) > 0.01) {
+                    return avgZoom;
                 }
             }
         } catch (_) {}
         
+        // Fallback: простой метод через screen размеры  
         try {
-            // Метод 3: Через тестовый элемент (проверяем разные единицы)
-            const testEl = document.createElement('div');
-            testEl.style.position = 'absolute';
-            testEl.style.left = '-9999px';
-            testEl.style.top = '-9999px';
-            testEl.style.width = '100px';
-            testEl.style.height = '100px';
-            testEl.style.visibility = 'hidden';
-            testEl.style.pointerEvents = 'none';
-            
-            document.body.appendChild(testEl);
-            
-            const rect = testEl.getBoundingClientRect();
-            const elemZoom = 100 / rect.width;
+            const screenRatio = screen.width / window.innerWidth;
+            const dpr = window.devicePixelRatio || 1;
+            const expectedRatio = dpr;
             
-            document.body.removeChild(testEl);
-            
-            if (isFinite(elemZoom) && elemZoom > 0.1 && elemZoom < 10) {
-                zoomFactors.push({ method: 'testElement', value: elemZoom });
+            if (Math.abs(screenRatio - expectedRatio) > 0.1) {
+                const zoomFactor = screenRatio / expectedRatio;
+                
+                if (isFinite(zoomFactor) && zoomFactor > 0.1 && zoomFactor < 10) {
+                    return zoomFactor;
+                }
             }
         } catch (_) {}
         
-        // Выбираем наиболее подходящий результат
-        if (zoomFactors.length === 0) {
-            return 1.0; // Fallback
-        }
-        
-        // Если есть visualViewport, предпочитаем его
-        const vpMethod = zoomFactors.find(f => f.method === 'visualViewport');
-        if (vpMethod) {
-            return vpMethod.value;
-        }
-        
-        // Иначе берем outerInner как наиболее стабильный
-        const outerMethod = zoomFactors.find(f => f.method === 'outerInner');
-        if (outerMethod) {
-            return outerMethod.value;
-        }
-        
-        // Последний fallback - первый доступный метод
-        return zoomFactors[0].value;
+        return 1.0; // Fallback: без коррекции
     }
 }