uicore-ts 1.1.310 → 1.1.312

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)