uicore-ts 1.1.310 → 1.1.315

package/scripts/UITextView.ts

@@ -12,6 +12,22 @@ export class UITextView extends UIView {
     
     static defaultTextColor = UIColor.blackColor
     static notificationTextColor = UIColor.redColor
+    static attentionRequiredColor = new UIColor("#f59e0b")
+    
+    /**
+     * Override this to customise the attention indicator HTML that is appended
+     * to a label's text when `attentionRequired` is `true`.
+     *
+     * The default renders an amber `●` dot:
+     * ```
+     * UITextView.renderAttentionIndicator = () =>
+     *     `<span style="color: #f59e0b; margin-left: 4px;">●</span>`
+     * ```
+     * Call sites never need to change — only this one function needs to be
+     * replaced at app startup to restyle every attention indicator globally.
+     */
+    static renderAttentionIndicator: () => string = () =>
+        "<span style=\"color: " + UITextView.attentionRequiredColor.stringValue + "; margin-left: 4px;\">●</span>"
     
     // Global caches for all UILabels
     static _intrinsicHeightCache: { [x: string]: { [x: string]: number; }; } & UIObject = new UIObject() as any
@@ -283,6 +299,10 @@ export class UITextView extends UIView {
             return false
         }
         
+        if (this._attentionRequired) {
+            return false
+        }
+        
         const hasComplexHTML = /<(?!\/?(b|i|em|strong|span)\b)[^>]+>/i.test(content)
         
         if (hasComplexHTML) {
@@ -401,6 +421,24 @@ export class UITextView extends UIView {
     
     //#endregion
     
+    //#region Getters & Setters - Attention Required
+    
+    get attentionRequired() {
+        return this._attentionRequired
+    }
+    
+    set attentionRequired(attentionRequired: boolean) {
+        if (this._attentionRequired == attentionRequired) {
+            return
+        }
+        
+        this._attentionRequired = attentionRequired
+        this.text = this.text
+        this.setNeedsLayoutUpToRootView()
+    }
+    
+    //#endregion
+    
     //#region Getters & Setters - Text Content
     
     get text() {
@@ -415,11 +453,16 @@ export class UITextView extends UIView {
                 (" (" + this.notificationAmount + ")").bold() + "</span>"
         }
         
+        var attentionDot = ""
+        if (this._attentionRequired) {
+            attentionDot = UITextView.renderAttentionIndicator()
+        }
+        
         const displayText = this.thousandsSeparator !== null
                             ? UITextView.applyThousandsSeparatorToNumericalString(text, this.thousandsSeparator)
                             : text
         
-        const newInnerHTML = this.textPrefix + FIRST(displayText, "") + this.textSuffix + notificationText
+        const newInnerHTML = this.textPrefix + FIRST(displayText, "") + this.textSuffix + notificationText + attentionDot
         
         if (this.textElementView.viewHTMLElement.innerHTML !== newInnerHTML) {
             this.textElementView.viewHTMLElement.innerHTML = newInnerHTML
@@ -626,6 +669,7 @@ export class UITextView extends UIView {
     textPrefix = ""
     textSuffix = ""
     _notificationAmount = 0
+    _attentionRequired = false
     
     _thousandsSeparator: string | null = null
     

package/scripts/UIView.ts

@@ -6,6 +6,7 @@ import "./UICoreExtensions"
 import type { UIDialogView } from "./UIDialogView"
 import { UILocalizedTextObject } from "./UIInterfaces"
 import { UILayoutCycleTracer } from "./UILayoutCycleTracer"
+import { UILayoutDebugger } from "./UILayoutDebugger"
 import {
     FIRST,
     FIRST_OR_NIL,
@@ -2033,6 +2034,7 @@ export class UIView extends UIObject {
         }
         
         window.UILayoutCycleTracer?.willBeginLayoutPass()
+        window.UILayoutDebugger?.willBeginLayoutPass(UIView._viewsToLayout)
         
         const maxIterations = 10
         let iteration = 0
@@ -2041,6 +2043,7 @@ export class UIView extends UIObject {
         while (UIView._viewsToLayout.length > 0 && iteration < maxIterations) {
             
             window.UILayoutCycleTracer?.willBeginIteration(iteration)
+            window.UILayoutDebugger?.willBeginIteration(iteration)
             
             const viewsToProcess = UIView._viewsToLayout
             UIView._viewsToLayout = []
@@ -2069,15 +2072,21 @@ export class UIView extends UIObject {
             
             for (let i = 0; i < sortedViews.length; i++) {
                 const view = sortedViews[i]
+                window.UILayoutDebugger?.willLayoutView(view)
+                if (window.UILayoutDebugger?._shouldHitBreakpoint(view)) {
+                    const breakpointOnThisLine = "Add a breakpoint on this line to step through layout."
+                }
                 view.layoutIfNeeded()
                 layoutCounts.set(view, (layoutCounts.get(view) || 0) + 1)
                 window.UILayoutCycleTracer?.didLayoutView(view)
+                window.UILayoutDebugger?.didLayoutView(view)
             }
             
             iteration++
         }
         
         window.UILayoutCycleTracer?.didFinishLayoutPass(iteration)
+        window.UILayoutDebugger?.didFinishLayoutPass(iteration)
         
         // console.log(iteration + " iterations to finish layout")
         
@@ -2097,6 +2106,7 @@ export class UIView extends UIObject {
         this.clearIntrinsicSizeCache()
         
         window.UILayoutCycleTracer?.viewDidCallSetNeedsLayout(this)
+        window.UILayoutDebugger?.viewDidCallSetNeedsLayout(this)
         
         // // Auto-propagate if intrinsic height changed
         // if (IS(this.superview) && this.superview.usesVirtualLayoutingForIntrinsicSizing) {
@@ -2133,7 +2143,7 @@ export class UIView extends UIObject {
         
         try {
             
-            if (this.bounds.width < 0) {
+            if (this.bounds.width < 0 || (!this.isVirtualLayouting && !this.isMemberOfViewTree)) {
                 return
             }
             
@@ -2167,12 +2177,14 @@ export class UIView extends UIObject {
         
         this.applyClassesAndStyles()
         
+        window.UILayoutDebugger?.willSetSubviewFrames(this)
         for (let i = 0; i < this.subviews?.length; i++) {
             
             const subview = this.subviews[i]
             subview.calculateAndSetViewFrame()
             
         }
+        window.UILayoutDebugger?.didSetSubviewFrames(this)
         
         // if (this._loadingView && this._loadingView.superview == this) {
         //     this._loadingView.setFrame(this.bounds)
@@ -4111,9 +4123,11 @@ export class UIView extends UIObject {
                 UIView._sharedIntrinsicSizeCaches.set(this.sharedIntrinsicSizeCacheIdentifier, bucket)
             }
             bucket[cacheKey] = size.copy()
+            window.UILayoutDebugger?.didSetCachedIntrinsicSize(this, cacheKey, size)
             return
         }
         this._intrinsicSizesCache[cacheKey] = size.copy()
+        window.UILayoutDebugger?.didSetCachedIntrinsicSize(this, cacheKey, size)
     }
     
     // clearIntrinsicSizeCache(): void {
@@ -4363,6 +4377,66 @@ export class UIView extends UIObject {
     }
     
     
+    /**
+     * ⚠️  NUCLEAR OPTION — DO NOT CALL IN NORMAL CODE  ⚠️
+     *
+     * Performs a full-scorched-earth cache purge across the entire view subtree rooted
+     * at `this`, then drives an immediate synchronous layout pass, as if the app had
+     * just cold-started.
+     *
+     * What gets destroyed:
+     *   • Every per-instance intrinsic-size cache entry (`_intrinsicSizesCache`)
+     *   • Every shared intrinsic-size cache bucket (`UIView._sharedIntrinsicSizeCaches`)
+     *   • Every frame cache (`_frameCache`) and virtual-layout frame cache
+     *     (`_frameCacheForVirtualLayouting`) on every view in the subtree
+     *   • Every UITextMeasurement style cache (canvas glyph metrics,
+     *     computed-style snapshots, etc.)
+     *
+     * After the purge every view in the subtree is unconditionally marked dirty via
+     * `setNeedsLayout()`, then `UIView.layoutViewsIfNeeded()` is called immediately
+     * to flush the queue rather than waiting for the next rAF tick.
+     *
+     * Legitimate uses (exhaustive list):
+     *   - Recovery from a confirmed cache-corruption bug while a proper fix ships
+     *   - Test harness reset between isolated rendering assertions
+     *   - Post-hot-module-replacement refresh in development tooling
+     *
+     * Do NOT use this to fix a layout glitch you don't understand.
+     * Fix the root cause instead.  If you find yourself calling this in production
+     * code for any reason other than the above, that is a bug — file it.
+     *
+     * Complexity: O(n) where n = total views in the subtree.
+     * All shared caches are wiped globally, not just for the subtree.
+     */
+    performForcedSubtreeLayout(): void {
+        
+        // 1. Nuke all text measurement caches globally — these are shared across
+        //    the entire document and cannot be scoped to a subtree.
+        UITextMeasurement.clearCaches()
+        
+        // 2. Wipe all shared intrinsic-size cache buckets globally.  These are
+        //    keyed by sharedIntrinsicSizeCacheIdentifier and may be shared across
+        //    views outside this subtree, but stale global state is worse than a
+        //    cold remeasure of an unrelated view.
+        UIView.invalidateAllSharedIntrinsicSizeCaches()
+        
+        // 3. Walk every view in the subtree and obliterate all per-instance caches,
+        //    then unconditionally schedule it for layout.
+        this.forEachViewInSubtree(view => {
+            view._intrinsicSizesCache = {}
+            view._frameCache = undefined
+            view._frameCacheForVirtualLayouting = undefined
+            view.setNeedsLayout()
+        })
+        
+        // 4. Drive the layout queue right now, synchronously — don't wait for the
+        //    scheduled rAF tick.  Callers of this method expect the tree to be
+        //    fully laid out by the time the call returns.
+        UIView.layoutViewsIfNeeded()
+        
+    }
+    
+    
 }
 
 

package/scripts/UIViewController.ts

@@ -187,6 +187,9 @@ export class UIViewController extends UIObject {
         if (IS(controller.view)) {
             controller.view.removeFromSuperview()
         }
+        else {
+            var asd = 1
+        }
         controller.viewDidDisappear()
         
     }
@@ -197,8 +200,12 @@ export class UIViewController extends UIObject {
         controller = FIRST_OR_NIL(controller)
         containerView = FIRST_OR_NIL(containerView)
         controller.viewWillAppear()
-        this.addChildViewController(controller)
-        containerView.addSubview(controller.view)
+        if (!this.hasChildViewController(controller)) {
+            controller.willMoveToParentViewController(this)
+            this.childViewControllers.push(controller)
+            containerView.addSubview(controller.view)
+            controller.didMoveToParentViewController(this)
+        }
         
         controller.handleRouteRecursively(UIRoute.currentRoute)