@nasser-sw/fabric 7.0.1-beta13 → 7.0.1-beta14

package/dist/src/shapes/Textbox.mjs

@@ -139,15 +139,8 @@ class Textbox extends IText {
         return;
       }
 
-      // Don't apply justify alignment during drag operations to prevent snapping
-      const now = Date.now();
-      const lastDragTime = this._lastInitDimensionsTime || 0;
-      const isDuringDrag = now - lastDragTime < 200; // 200ms window for drag detection
-
-      if (isDuringDrag) {
-        console.log('🔤 Skipping justify during drag operation to prevent snapping');
-        return;
-      }
+      // Note: Removed drag detection logic that was causing issues
+      // Justify alignment will now apply immediately when needed
 
       // For non-browser-wrapping fonts, use Fabric's justify system
       // once text is measured we need to make space fatter to make justified text.
@@ -207,7 +200,9 @@ class Textbox extends IText {
     }
 
     // Double-check that justify was applied by checking space widths
-    if (this.textAlign.includes('justify') && this.__charBounds) {
+    // Skip validation during rapid width changes to prevent interference
+    console.log('🔍 JUSTIFY CHECK:', this.textAlign.includes('justify'), !!this.__charBounds, !this._skipJustifyValidation);
+    if (this.textAlign.includes('justify') && this.__charBounds && !this._skipJustifyValidation) {
       setTimeout(() => {
         // Verify justify was applied by checking if space widths vary
         let hasVariableSpaces = false;
@@ -720,7 +715,8 @@ class Textbox extends IText {
    */
   _splitTextIntoLines(text) {
     // Check if we need browser wrapping using smart font detection
-    const needsBrowserWrapping = this.fontFamily && fontLacksEnglishGlyphsCached(this.fontFamily);
+    // Skip browser wrapping for justify text when using overlay editing to prevent measurement conflicts
+    const needsBrowserWrapping = this.fontFamily && fontLacksEnglishGlyphsCached(this.fontFamily) && !(this.textAlign.includes('justify') && this.useOverlayEditing);
     if (needsBrowserWrapping) {
       // Cache key based on text content, width, font properties, AND text alignment
       const textHash = text.length + text.slice(0, 50); // Include text content in cache key
@@ -745,6 +741,11 @@ class Textbox extends IText {
 
       // Mark that we used browser wrapping to prevent dynamicMinWidth modifications
       this._usingBrowserWrapping = true;
+
+      // pass the width to enlargeSpaces
+      if (result.width) {
+        this._browserWrappingWidth = result.width;
+      }
       return result;
     }
 
@@ -773,26 +774,47 @@ class Textbox extends IText {
       return this._splitTextIntoLinesDefault(text);
     }
 
+    // Skip measurement if we just extracted lines from overlay for justify text
+    if (this._skipJustifyMeasurement && this.textAlign.includes('justify')) {
+      console.log('🚫 SKIP: Skipping browser measurement, using stored overlay lines');
+      this._skipJustifyMeasurement = false; // Reset flag
+      return this._splitTextIntoLinesDefault(text);
+    }
+
     // Create a hidden element that mimics the overlay editor
     const testElement = document.createElement('div');
     testElement.style.position = 'absolute';
     testElement.style.left = '-9999px';
     testElement.style.visibility = 'hidden';
-    testElement.style.fontSize = `${this.fontSize}px`;
+    const scaleX = this.scaleX || 1;
+    const fontSize = this.fontSize * scaleX;
+    const padding = this.padding || 0;
+    testElement.style.fontSize = `${fontSize}px`;
     testElement.style.fontFamily = `"${this.fontFamily}"`;
     testElement.style.fontWeight = String(this.fontWeight || 'normal');
     testElement.style.fontStyle = String(this.fontStyle || 'normal');
     testElement.style.lineHeight = String(this.lineHeight || 1.16);
-    testElement.style.width = `${this.width}px`;
+    testElement.style.letterSpacing = `${(this.charSpacing || 0) / 1000 * fontSize}px`;
     testElement.style.direction = this.direction || 'ltr';
     testElement.style.whiteSpace = 'pre-wrap';
     testElement.style.wordBreak = 'normal';
     testElement.style.overflowWrap = 'break-word';
-
-    // Set browser-native text alignment (including justify)
+    testElement.style.padding = `${padding}px`;
+    testElement.style.boxSizing = 'border-box';
+    testElement.style.width = `${this.width * scaleX + padding * 2}px`;
     if (this.textAlign.includes('justify')) {
       testElement.style.textAlign = 'justify';
-      testElement.style.textAlignLast = 'auto'; // Let browser decide last line alignment
+      if (this.direction === 'rtl') {
+        testElement.style.textAlignLast = 'right';
+      } else {
+        testElement.style.textAlignLast = 'left';
+      }
+      testElement.style.textJustify = 'inter-word';
+      testElement.style.unicodeBidi = 'plaintext';
+      testElement.style.wordSpacing = 'normal';
+      // Match font smoothing from overlay editor
+      testElement.style.webkitFontSmoothing = 'auto';
+      testElement.style.mozOsxFontSmoothing = 'auto';
     } else {
       testElement.style.textAlign = this.textAlign;
     }
@@ -817,7 +839,7 @@ class Textbox extends IText {
           if (i > currentLineStart && (rect.bottom > previousBottom + 5 || i === textLength)) {
             // New line detected or end of text
             const lineEnd = i === textLength ? i : i - 1;
-            const lineText = text.substring(currentLineStart, lineEnd).trim();
+            const lineText = text.substring(currentLineStart, lineEnd);
             if (lineText) {
               lines.push(lineText);
               // Convert to graphemes for compatibility
@@ -840,6 +862,7 @@ class Textbox extends IText {
     const offsetHeight = testElement.offsetHeight;
     const clientHeight = testElement.clientHeight;
     const boundingRect = testElement.getBoundingClientRect();
+    const clientWidth = testElement.clientWidth;
     console.log(`🔤 Browser element measurements:`);
     console.log(`   scrollHeight: ${actualBrowserHeight}px (content + padding + hidden overflow)`);
     console.log(`   offsetHeight: ${offsetHeight}px (content + padding + border)`);
@@ -887,7 +910,8 @@ class Textbox extends IText {
       graphemeText: text.split(''),
       graphemeLines: graphemeLines,
       justifySpaceMeasurements: justifySpaceMeasurements,
-      actualBrowserHeight: adjustedHeight
+      actualBrowserHeight: adjustedHeight,
+      width: clientWidth
     };
   }
 
@@ -939,6 +963,14 @@ class Textbox extends IText {
       return;
     }
 
+    // Check for overlay justify measurements first
+    const overlayMeasurements = this._overlayJustifyMeasurements;
+    if (overlayMeasurements) {
+      console.log('🎯 OVERLAY JUSTIFY: Using stored overlay measurements');
+      this._applyOverlayJustifySpaces(overlayMeasurements);
+      return;
+    }
+
     // Get space measurements from browser wrapping result
     const styleMap = this._styleMap;
     if (!styleMap || !styleMap.justifySpaceMeasurements) {
@@ -1004,6 +1036,111 @@ class Textbox extends IText {
     });
   }
 
+  /**
+   * Apply overlay justify measurements to character bounds
+   * @private
+   */
+  _applyOverlayJustifySpaces(overlayMeasurements) {
+    this._textLines.forEach((line, lineIndex) => {
+      if (!this.__charBounds || !this.__charBounds[lineIndex]) return;
+      const lineMeasurement = overlayMeasurements[lineIndex];
+      if (!lineMeasurement) return;
+      const {
+        justifiedSpaceWidth
+      } = lineMeasurement;
+      let spaceIndex = 0;
+      line.forEach((char, charIndex) => {
+        if (char === ' ' && this.__charBounds[lineIndex][charIndex]) {
+          const oldWidth = this.__charBounds[lineIndex][charIndex].width;
+          this.__charBounds[lineIndex][charIndex].width = justifiedSpaceWidth;
+          console.log(`🎯 OVERLAY Line ${lineIndex} space ${spaceIndex}: ${oldWidth.toFixed(1)}px -> ${justifiedSpaceWidth.toFixed(1)}px`);
+          spaceIndex++;
+        }
+      });
+    });
+  }
+
+  /**
+   * Extract justify measurements from overlay textarea and store them
+   */
+  extractJustifyMeasurementsFromOverlay(textarea) {
+    const text = textarea.value;
+    if (!text || !this.textAlign.includes('justify')) {
+      return;
+    }
+
+    // Use the same measurement technique as measureLinesWithBrowser
+    const testElement = document.createElement('div');
+    testElement.style.position = 'absolute';
+    testElement.style.left = '-9999px';
+    testElement.style.visibility = 'hidden';
+
+    // Copy all styles from the textarea to ensure identical rendering
+    const computedStyle = window.getComputedStyle(textarea);
+    const stylesToCopy = ['fontSize', 'fontFamily', 'fontWeight', 'fontStyle', 'lineHeight', 'letterSpacing', 'direction', 'textAlign', 'textAlignLast', 'textJustify', 'width', 'padding', 'boxSizing', 'whiteSpace', 'wordBreak', 'overflowWrap'];
+    stylesToCopy.forEach(prop => {
+      testElement.style[prop] = computedStyle[prop];
+    });
+    testElement.textContent = text;
+    document.body.appendChild(testElement);
+    try {
+      // Extract justify space measurements using the same logic
+      const lines = text.split('\n');
+      const justifyMeasurements = {};
+      lines.forEach((line, lineIndex) => {
+        if (line.trim()) {
+          const spaces = (line.match(/\s/g) || []).length;
+          if (spaces > 0) {
+            // Measure natural space width
+            const singleSpaceDiv = document.createElement('div');
+            stylesToCopy.forEach(prop => {
+              singleSpaceDiv.style[prop] = computedStyle[prop];
+            });
+            singleSpaceDiv.textContent = ' ';
+            document.body.appendChild(singleSpaceDiv);
+            const naturalSpaceWidth = singleSpaceDiv.getBoundingClientRect().width;
+            document.body.removeChild(singleSpaceDiv);
+
+            // Measure justified line width
+            const lineDiv = document.createElement('div');
+            stylesToCopy.forEach(prop => {
+              lineDiv.style[prop] = computedStyle[prop];
+            });
+            lineDiv.textContent = line;
+            document.body.appendChild(lineDiv);
+            const lineWidth = lineDiv.getBoundingClientRect().width;
+            const containerWidth = parseFloat(computedStyle.width);
+
+            // Calculate justified space width
+            const nonSpaceText = line.replace(/\s/g, '');
+            const nonSpaceDiv = document.createElement('div');
+            stylesToCopy.forEach(prop => {
+              nonSpaceDiv.style[prop] = computedStyle[prop];
+            });
+            nonSpaceDiv.textContent = nonSpaceText;
+            document.body.appendChild(nonSpaceDiv);
+            const nonSpaceWidth = nonSpaceDiv.getBoundingClientRect().width;
+            const justifiedSpaceWidth = (containerWidth - nonSpaceWidth) / spaces;
+            console.log(`🎯 OVERLAY Line ${lineIndex}: ${spaces} spaces, natural: ${naturalSpaceWidth.toFixed(1)}px -> justified: ${justifiedSpaceWidth.toFixed(1)}px`);
+            justifyMeasurements[lineIndex] = {
+              naturalSpaceWidth,
+              justifiedSpaceWidth,
+              spaceCount: spaces
+            };
+            document.body.removeChild(lineDiv);
+            document.body.removeChild(nonSpaceDiv);
+          }
+        }
+      });
+
+      // Store the measurements
+      this._overlayJustifyMeasurements = justifyMeasurements;
+      console.log('💾 STORED: Overlay justify measurements', justifyMeasurements);
+    } finally {
+      document.body.removeChild(testElement);
+    }
+  }
+
   /**
    * Fallback to default Fabric wrapping
    * @private
@@ -1068,6 +1205,7 @@ class Textbox extends IText {
     // Use 'modified' event which fires after user releases the mouse
     this.on('modified', () => {
       const currentResizeOrigin = resizeOrigin; // Capture the value before reset
+      this.initDimensions();
       // Small delay to ensure text layout is updated
       setTimeout(() => this.safetySnapWidth(currentResizeOrigin), 10);
       resizeOrigin = null; // Reset after capturing
@@ -1127,7 +1265,7 @@ class Textbox extends IText {
       const originalTop = this.top;
       const widthIncrease = newWidth - this.width;
 
-      // Change width 
+      // Change width
       this.set('width', newWidth);
 
       // Force text layout recalculation
@@ -1139,8 +1277,8 @@ class Textbox extends IText {
         // When resizing from left, the expansion pushes text right
         // Compensate by moving the textbox left by the width increase
         this.set({
-          'left': originalLeft - widthIncrease,
-          'top': originalTop
+          left: originalLeft - widthIncrease,
+          top: originalTop
         });
       }
       this.setCoords();
@@ -1236,6 +1374,35 @@ class Textbox extends IText {
     }
   }
 
+  /**
+   * Fix justify text after JSON loading - call this after fromObject
+   * @public
+   */
+  fixJustifyAfterJSONLoad() {
+    if (this.textAlign.includes('justify') && this.useOverlayEditing) {
+      console.log('🔧 JSON FIX: Fixing justify text after JSON load');
+      // The issue is that enlargeSpaces() isn't properly updating after JSON load
+      // Workaround: temporarily change width to trigger proper rebuild, then restore
+      setTimeout(() => {
+        const originalWidth = this.width;
+        console.log('🔄 JSON TRICK: Temporarily changing width to force justify rebuild');
+
+        // Temporarily change width by 1px to trigger proper justify recalculation
+        this.width = originalWidth + 1;
+        this.initDimensions();
+
+        // Restore original width - this will trigger the proper justify calculation
+        setTimeout(() => {
+          var _this$canvas8;
+          this.width = originalWidth;
+          this.initDimensions();
+          (_this$canvas8 = this.canvas) === null || _this$canvas8 === void 0 || _this$canvas8.requestRenderAll();
+          console.log('✅ JSON FIX: Restored original width, justify should be fixed');
+        }, 50);
+      }, 100);
+    }
+  }
+
   /**
    * Returns object representation of an instance
    * @param {Array} [propertiesToInclude] Any properties that you might want to additionally include in the output
@@ -1243,7 +1410,60 @@ class Textbox extends IText {
    */
   toObject() {
     let propertiesToInclude = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-    return super.toObject(['minWidth', 'splitByGrapheme', ...propertiesToInclude]);
+    const obj = super.toObject(['minWidth', 'splitByGrapheme', ...propertiesToInclude]);
+
+    // For justify text with overlay editing, ensure measurements are available
+    if (this.textAlign.includes('justify') && this.useOverlayEditing) {
+      var _charBounds, _charBounds2;
+      // If character bounds don't exist yet, initialize dimensions to calculate them
+      if (!((_charBounds = this.__charBounds) !== null && _charBounds !== void 0 && _charBounds.length)) {
+        console.log('🔧 SERIALIZE: Character bounds missing, initializing dimensions for justify text');
+        this.initDimensions();
+      }
+
+      // Now save the measurements if they exist
+      if ((_charBounds2 = this.__charBounds) !== null && _charBounds2 !== void 0 && _charBounds2.length) {
+        console.log('💾 SERIALIZE: Saving justify measurements to JSON');
+        obj._justifyMeasurements = {
+          __charBounds: this.__charBounds,
+          __lineHeights: this.__lineHeights,
+          __lineWidths: this.__lineWidths,
+          _hasJustifyData: true
+        };
+      } else {
+        console.warn('⚠️ SERIALIZE: Could not generate character bounds for justify text');
+      }
+    }
+    return obj;
+  }
+
+  /**
+   * Override _set to handle justify measurements during JSON loading
+   * @private
+   */
+  _set(key, value) {
+    const result = super._set(key, value);
+
+    // Restore justify measurements if they exist in the JSON data
+    if (key === '_justifyMeasurements' && value && value._hasJustifyData) {
+      console.log('🔄 DESERIALIZE: Restoring justify measurements from JSON');
+      this.__charBounds = value.__charBounds;
+      this.__lineHeights = value.__lineHeights;
+      this.__lineWidths = value.__lineWidths;
+
+      // Mark that we have restored data so we don't interfere with it
+      this._hasRestoredJustifyData = true;
+
+      // Automatically trigger the fix after JSON loading
+      if (this.textAlign.includes('justify') && this.useOverlayEditing) {
+        console.log('🔄 AUTO-FIX: Calling fixJustifyAfterJSONLoad after restoring justify measurements');
+        // Use setTimeout to ensure this runs after all object initialization is complete
+        setTimeout(() => {
+          this.fixJustifyAfterJSONLoad();
+        }, 10);
+      }
+    }
+    return result;
   }
 }
 /**