uicore-ts 1.1.57 → 1.1.59

package/scripts/UITextView.ts

@@ -3,7 +3,7 @@ import { UILocalizedTextObject } from "./UIInterfaces"
 import { FIRST, IS, IS_LIKE_NULL, nil, NO, UIObject, YES } from "./UIObject"
 import { UIRectangle } from "./UIRectangle"
 import type { ValueOf } from "./UIObject"
-import { UITextMeasurement } from "./UITextMeasurement"
+import { TextMeasurementStyle, UITextMeasurement } from "./UITextMeasurement"
 import { UIView, UIViewBroadcastEvent } from "./UIView"
 
 
@@ -42,6 +42,7 @@ export class UITextView extends UIView {
     _text?: string
     
     private _useFastMeasurement: boolean | undefined;
+    private _cachedMeasurementStyles: TextMeasurementStyle | undefined;
     
     
     constructor(
@@ -167,6 +168,8 @@ export class UITextView extends UIView {
         
         this.style.whiteSpace = "pre-wrap"
         
+        this.invalidateMeasurementStrategy()
+        
     }
     
     
@@ -225,6 +228,8 @@ export class UITextView extends UIView {
         // Invalidate measurement strategy when text changes significantly
         this._useFastMeasurement = undefined;
         this._intrinsicSizesCache = {};
+        this.invalidateMeasurementStrategy()
+        this._invalidateMeasurementStyles()
         
         this.setNeedsLayout()
         
@@ -233,6 +238,7 @@ export class UITextView extends UIView {
     override set innerHTML(innerHTML: string) {
         
         this.text = innerHTML
+        this.invalidateMeasurementStrategy()
         
     }
     
@@ -246,13 +252,14 @@ export class UITextView extends UIView {
     setText(key: string, defaultString: string, parameters?: { [x: string]: string | UILocalizedTextObject }) {
         
         this.setInnerHTML(key, defaultString, parameters)
+        this.invalidateMeasurementStrategy()
         
     }
     
     
     get fontSize() {
         
-        const style = window.getComputedStyle(this.viewHTMLElement, null).fontSize
+        const style = this.style.fontSize || window.getComputedStyle(this.viewHTMLElement, null).fontSize
         
         const result = (parseFloat(style) * UITextView._pxToPt)
         
@@ -262,29 +269,30 @@ export class UITextView extends UIView {
     
     set fontSize(fontSize: number) {
         
+        if (fontSize != this.fontSize) {
+            
+            this.style.fontSize = "" + fontSize + "pt"
+            
+            this._intrinsicHeightCache = new UIObject() as any
+            this._intrinsicWidthCache = new UIObject() as any // MEETOD LUUA!!!!
+            
+            this._invalidateMeasurementStyles()  // Invalidate when font changes
         
-        this.style.fontSize = "" + fontSize + "pt"
-        
-        this._intrinsicHeightCache = new UIObject() as any
-        this._intrinsicWidthCache = new UIObject() as any // MEETOD LUUA!!!!
-        
+        }
         
     }
     
     
+    
     useAutomaticFontSize(minFontSize: number = nil, maxFontSize: number = nil) {
         
-        
         this._automaticFontSizeSelection = YES
         
-        
         this._minFontSize = minFontSize
-        
         this._maxFontSize = maxFontSize
         
         this.setNeedsLayout()
         
-        
     }
     
     
@@ -297,44 +305,28 @@ export class UITextView extends UIView {
     ) {
         
         minFontSize = FIRST(minFontSize, 1)
-        
         maxFontSize = FIRST(maxFontSize, 100000000000)
         
-        
         const heightMultiplier = bounds.height / (currentSize.height + 1)
-        
         const widthMultiplier = bounds.width / (currentSize.width + 1)
         
-        
         var multiplier = heightMultiplier
-        
         if (heightMultiplier > widthMultiplier) {
-            
             multiplier = widthMultiplier
-            
-            
         }
         
-        
         const maxFittingFontSize = currentFontSize * multiplier
         
-        
         if (maxFittingFontSize > maxFontSize) {
-            
             return maxFontSize
-            
         }
         
         if (minFontSize > maxFittingFontSize) {
-            
             return minFontSize
-            
         }
         
-        
         return maxFittingFontSize
         
-        
     }
     
     
@@ -449,6 +441,58 @@ export class UITextView extends UIView {
     }
     
     
+    // Call this when styles change (fontSize, padding, etc.)
+    private _invalidateMeasurementStyles(): void {
+        this._cachedMeasurementStyles = undefined;
+        UITextMeasurement.invalidateElement(this.viewHTMLElement);
+        this._intrinsicSizesCache = {};
+    }
+    
+    // Extract styles ONCE and cache them (avoids getComputedStyle)
+    private _getMeasurementStyles(): TextMeasurementStyle {
+        if (this._cachedMeasurementStyles) {
+            return this._cachedMeasurementStyles;
+        }
+        
+        // Only call getComputedStyle once and cache the result
+        const computed = window.getComputedStyle(this.viewHTMLElement);
+        const fontSize = parseFloat(computed.fontSize);
+        
+        this._cachedMeasurementStyles = {
+            font: [
+                computed.fontStyle,
+                computed.fontVariant,
+                computed.fontWeight,
+                computed.fontSize,
+                computed.fontFamily
+            ].join(' '),
+            fontSize: fontSize,
+            lineHeight: this._parseLineHeight(computed.lineHeight, fontSize),
+            whiteSpace: computed.whiteSpace,
+            paddingLeft: parseFloat(computed.paddingLeft) || 0,
+            paddingRight: parseFloat(computed.paddingRight) || 0,
+            paddingTop: parseFloat(computed.paddingTop) || 0,
+            paddingBottom: parseFloat(computed.paddingBottom) || 0
+        };
+        
+        return this._cachedMeasurementStyles;
+    }
+    
+    private _parseLineHeight(lineHeight: string, fontSize: number): number {
+        if (lineHeight === 'normal') {
+            return fontSize * 1.2;
+        }
+        if (lineHeight.endsWith('px')) {
+            return parseFloat(lineHeight);
+        }
+        const numericLineHeight = parseFloat(lineHeight);
+        if (!isNaN(numericLineHeight)) {
+            return fontSize * numericLineHeight;
+        }
+        return fontSize * 1.2;
+    }
+    
+    // Override the intrinsic size method
     override intrinsicContentSizeWithConstraints(
         constrainingHeight: number = 0,
         constrainingWidth: number = 0
@@ -465,12 +509,14 @@ export class UITextView extends UIView {
         let result: UIRectangle;
         
         if (shouldUseFastPath) {
-            // Fast path: canvas-based measurement
+            // Fast path: canvas-based measurement with pre-extracted styles
+            const styles = this._getMeasurementStyles();
             const size = UITextMeasurement.calculateTextSize(
                 this.viewHTMLElement,
                 this.text || this.innerHTML,
                 constrainingWidth || undefined,
-                constrainingHeight || undefined
+                constrainingHeight || undefined,
+                styles  // Pass pre-computed styles to avoid getComputedStyle!
             );
             result = new UIRectangle(0, 0, size.height, size.width);
         } else {
@@ -487,7 +533,7 @@ export class UITextView extends UIView {
         const content = this.text || this.innerHTML;
         
         // If using dynamic innerHTML with parameters, use DOM measurement
-        if (IS(this._innerHTMLKey) || IS(this._localizedTextObject)) {
+        if (this._innerHTMLKey || this._localizedTextObject) {
             return false;
         }
         
@@ -511,11 +557,13 @@ export class UITextView extends UIView {
     // Optional: Force re-evaluation of measurement strategy
     invalidateMeasurementStrategy(): void {
         this._useFastMeasurement = undefined;
-        this._intrinsicSizesCache = {};
+        this._invalidateMeasurementStyles();
     }
     
     
     
+    
+    
     override intrinsicContentSize() {
         
         // This works but is slow

package/scripts/UIView.ts

@@ -1944,9 +1944,14 @@ export class UIView extends UIObject {
     }
     
     
+    cancelNeedsLayout() {
+        this._shouldLayout = NO
+    }
+    
     removeFromSuperview() {
         if (IS(this.superview)) {
             this.forEachViewInSubtree(view => view.blur())
+            this.cancelNeedsLayout()
             const index = this.superview.subviews.indexOf(this)
             if (index > -1) {
                 this.superview.subviews.splice(index, 1)