uicore-ts 1.1.115 → 1.1.118

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uicore-ts",
-  "version": "1.1.115",
+  "version": "1.1.118",
   "description": "UICore is a library to build native-like user interfaces using pure Typescript. No HTML is needed at all. Components are described as TS classes and all user interactions are handled explicitly. This library is strongly inspired by the UIKit framework that is used in IOS. In addition, UICore has tools to handle URL based routing, array sorting and filtering and adds a number of other utilities for convenience.",
   "main": "compiledScripts/index.js",
   "types": "compiledScripts/index.d.ts",

package/scripts/UIButton.ts

@@ -311,7 +311,7 @@ export class UIButton extends UIBaseButton {
         
         let bounds = this.bounds
         
-        this.hoverText = this.titleLabel?.text ?? ""
+        this.hoverText = this.hoverText ?? this.titleLabel?.text ?? ""
         
         // Image only if text is not present
         if (IS_NOT(this.imageView.hidden) && !IS(this.titleLabel?.text)) {

package/scripts/UICore.ts

@@ -10,7 +10,7 @@ export class UICore extends UIObject {
     
     rootViewController: UIViewController
     
-    paddingLength = 20
+    
     
     static RootViewControllerClass: typeof UIViewController
     static main: UICore
@@ -24,7 +24,7 @@ export class UICore extends UIObject {
         
     }
     
-    constructor(rootDivElementID: string, rootViewControllerClass: typeof UIViewController) {
+    constructor(rootDivElementID: string, rootViewControllerClass: typeof UIViewController, public paddingLength = 20) {
         
         super()
         

package/scripts/UIDialogView.ts

@@ -118,9 +118,11 @@ export class UIDialogView<ViewType extends UIView = UIView> extends UIView {
         
         
         containerView.addSubview(this)
+        this.view.setNeedsLayoutUpToRootView()
         
         if (animated) {
             
+            UIView.layoutViewsIfNeeded()
             this.layoutSubviews()
             
             UIView.animateViewOrViewsWithDurationDelayAndFunction(
@@ -250,6 +252,8 @@ export class UIDialogView<ViewType extends UIView = UIView> extends UIView {
         
         this.view.style.zIndex = "" + this.zIndex
         
+        this.view.setNeedsLayout()
+        
         // this.view.style.maxHeight = "" + (bounds.height - margin * 2).integerValue + "px";
         // this.view.style.maxWidth = "" + (bounds.width - margin * 2).integerValue + "px";
         

package/scripts/UIRectangle.ts

@@ -1016,13 +1016,12 @@ export class UIRectangle extends UIObject {
 // 1. Methods available when holding a UIRectangle
 type RectangleChainMethods<TResult> = {
     [K in keyof UIRectangle as (
-        // Exclude IF to prevent circular reference TS2615
-        // Exclude Control Flow keys as they are handled in SharedChainMethods
         K extends 'IF' | 'ELSE' | 'ELSE_IF' | 'ENDIF' ? never : K
         )]:
     UIRectangle[K] extends (...args: infer Args) => infer R
-    ? R extends UIRectangle | UIRectangle[] // Filter: Must return Rect or Rect[]
-      ? (...args: Args) => UIRectangleConditionalChain<R, TResult | R>
+    ? R extends UIRectangle | UIRectangle[]
+        // CHANGE: We do NOT add 'R' to 'TResult' here. We only update the current state (R).
+      ? (...args: Args) => UIRectangleConditionalChain<R, TResult>
       : never
     : never
 };
@@ -1030,68 +1029,67 @@ type RectangleChainMethods<TResult> = {
 // 2. Methods available when holding a UIRectangle[]
 type ArrayChainMethods<TResult> = {
     [K in keyof UIRectangle[]]:
-    // Case 1: It is a property (getter) that returns a UIRectangle
     UIRectangle[][K] extends UIRectangle
-    ? UIRectangleConditionalChain<UIRectangle, TResult | UIRectangle>
-        // Case 2: It is a function that returns a UIRectangle
+    ? UIRectangleConditionalChain<UIRectangle, TResult> // No accumulation for properties
     : UIRectangle[][K] extends (...args: infer Args) => infer R
-      ? R extends UIRectangle
-        ? (...args: Args) => UIRectangleConditionalChain<R, TResult | R>
+      ? R extends UIRectangle | UIRectangle[]
+          // CHANGE: We do NOT add 'R' to 'TResult' here either.
+        ? (...args: Args) => UIRectangleConditionalChain<R, TResult>
         : never
       : never
 };
 
-
-
 // 3. Methods available in both states (Control Flow + Transform)
 type SharedChainMethods<TCurrent, TResult> = {
-    // TRANSFORM allows manual conversion from TCurrent to a UIRectangle
-    TRANSFORM<R extends UIRectangle>(fn: (current: TCurrent) => R): UIRectangleConditionalChain<R, TResult | R>;
+    // TRANSFORM acts as a standard method, it should not leak intermediate types into TResult
+    TRANSFORM<R extends UIRectangle>(fn: (current: TCurrent) => R): UIRectangleConditionalChain<R, TResult>;
+    
+    // ELSE_IF marks the end of a branch. We MUST capture the current state (TCurrent) and add it to TResult.
+    // The new chain starts with the original UIRectangle state for the next branch.
+    ELSE_IF(condition: boolean): UIRectangleConditionalChain<UIRectangle, TResult | TCurrent>;
     
-    // ELSE_IF and ELSE reset the state to the base UIRectangle
-    ELSE_IF<U>(condition: boolean): UIRectangleConditionalChain<UIRectangle, TResult | U>;
-    ELSE<U>(): UIRectangleConditionalChain<UIRectangle, TResult | U>;
+    // ELSE marks the end of a branch. Same logic as ELSE_IF.
+    ELSE(): UIRectangleConditionalChain<UIRectangle, TResult | TCurrent>;
     
-    // ENDIF returns the final result
-    ENDIF(): TResult;
-    ENDIF<R>(performFunction: (result: TResult) => R): R;
+    // ENDIF marks the end of the block. Same logic: capture TCurrent into TResult.
+    ENDIF(): TResult | TCurrent;
+    ENDIF<R>(performFunction: (result: TResult | TCurrent) => R): R;
 };
 
-// 4. The Main Type
-// Conditionally combines the specific methods based on TCurrent, plus the shared methods
+// 4. The Main Type (No changes needed here, just re-stating for context)
 type UIRectangleConditionalChain<TCurrent, TResult = TCurrent> =
-// Use {} instead of never to avoid collapsing the intersection to 'never'
     (TCurrent extends UIRectangle ? RectangleChainMethods<TResult> : {}) &
     (TCurrent extends UIRectangle[] ? ArrayChainMethods<TResult> : {}) &
     SharedChainMethods<TCurrent, TResult>;
 
 
 class UIRectangleConditionalBlock {
-    private parentRectangle: UIRectangle
-    private conditionMet: boolean
-    private branchHasExecuted: boolean = false
+    // The value we are currently chaining on (can be UIRectangle or UIRectangle[])
     private currentResult: any
+    // The value where the IF block started (needed to reset for ELSE branches)
+    private originalResult: any
+    private conditionMet: boolean
     
-    constructor(rectangle: UIRectangle, condition: boolean, initialResult?: any) {
-        this.parentRectangle = rectangle
+    constructor(initialResult: UIRectangle, condition: boolean) {
+        this.originalResult = initialResult
+        this.currentResult = initialResult
         this.conditionMet = condition
-        this.currentResult = initialResult ?? rectangle
     }
     
     private createProxy(): UIRectangleConditionalChain<any, any> {
         const self = this
-        return new Proxy(this.parentRectangle, {
-            get(target, prop) {
+        
+        // The target is irrelevant; we delegate everything to self.currentResult
+        return new Proxy({}, {
+            get(_, prop) {
+                
+                // 1. Control Flow Methods
                 
-                // 1. Handle Control Flow Methods
                 if (prop === 'TRANSFORM') {
                     return <R extends UIRectangle>(fn: (current: any) => R) => {
                         if (self.conditionMet) {
                             const result = fn(self.currentResult)
                             self.currentResult = result
-                            if (result instanceof UIRectangle) {
-                                self.parentRectangle = result
-                            }
                         }
                         return self.createProxy()
                     }
@@ -1099,31 +1097,24 @@ class UIRectangleConditionalBlock {
                 
                 if (prop === 'ELSE_IF') {
                     return <U>(condition: boolean) => {
-                        if (!self.branchHasExecuted && !self.conditionMet) {
+                        // Only enter this branch if no previous branch has run
+                        if (!self.conditionMet) {
                             self.conditionMet = condition
+                            // Reset the state to the original starting point for this new branch
+                            self.currentResult = self.originalResult
                         }
-                        const newBlock = new UIRectangleConditionalBlock(
-                            self.parentRectangle,
-                            self.conditionMet,
-                            self.currentResult
-                        )
-                        newBlock.branchHasExecuted = self.branchHasExecuted
-                        return newBlock.createProxy()
+                        return self.createProxy()
                     }
                 }
                 
                 if (prop === 'ELSE') {
                     return <U>() => {
-                        if (!self.branchHasExecuted && !self.conditionMet) {
+                        if (!self.conditionMet) {
                             self.conditionMet = true
+                            // Reset the state to the original starting point
+                            self.currentResult = self.originalResult
                         }
-                        const newBlock = new UIRectangleConditionalBlock(
-                            self.parentRectangle,
-                            self.conditionMet,
-                            self.currentResult
-                        )
-                        newBlock.branchHasExecuted = self.branchHasExecuted
-                        return newBlock.createProxy()
+                        return self.createProxy()
                     }
                 }
                 
@@ -1131,77 +1122,34 @@ class UIRectangleConditionalBlock {
                     function endif(): any
                     function endif<R>(performFunction: (result: any) => R): R
                     function endif<R>(performFunction?: (result: any) => R): R | any {
-                        if (performFunction) {
-                            return performFunction(self.currentResult)
-                        }
-                        return self.currentResult
+                        return performFunction ? performFunction(self.currentResult) : self.currentResult
                     }
                     return endif
                 }
                 
-                // 2. Handle Array State
-                const isArrayState = Array.isArray(self.currentResult)
+                // 2. Forwarding to currentResult (Rectangle or Array)
+                
+                const value = self.currentResult[prop]
                 
-                if (isArrayState) {
-                    const array = self.currentResult
-                    const descriptor = Object.getOwnPropertyDescriptor(Array.prototype, prop)
-                    
-                    // Case A: It's a method on the Array prototype
-                    if (descriptor && descriptor.value instanceof Function) {
-                        return (...args: any[]) => {
-                            if (self.conditionMet) {
-                                if (!self.branchHasExecuted) self.branchHasExecuted = true
-                                const result = descriptor.value.apply(array, args)
-                                self.currentResult = result
-                                if (result instanceof UIRectangle) {
-                                    self.parentRectangle = result
-                                }
-                            }
-                            return self.createProxy()
+                // Case A: It's a function (method call)
+                if (typeof value === 'function') {
+                    return (...args: any[]) => {
+                        if (self.conditionMet) {
+                            // Call the method on the CURRENT object, and update the state
+                            const result = value.apply(self.currentResult, args)
+                            self.currentResult = result
                         }
+                        return self.createProxy()
                     }
-                    
-                    // Case B: It's a getter/property on the Array prototype (e.g., lastElement)
-                    // We access the value on the array instance
-                    const value = array[prop]
-                    
-                    if (value instanceof UIRectangle) {
-                        // Special handling: If accessing a property that is a UIRectangle,
-                        // we treat it as a transition to keep the chain alive.
-                        return (() => {
-                            if (self.conditionMet) {
-                                if (!self.branchHasExecuted) self.branchHasExecuted = true
-                                self.currentResult = value
-                                self.parentRectangle = value
-                            }
-                            return self.createProxy()
-                        })()
-                    }
-                    
-                    // Case C: Other properties (like 'length', 'map', etc) -> Return raw value
-                    // This breaks the chain, which is expected behavior for non-Rectangle properties
-                    return value
                 }
                 
-                // 3. Handle Rectangle State
-                else {
-                    const value = target[prop as keyof UIRectangle]
-                    if (value instanceof Function) {
-                        return (...args: any[]) => {
-                            if (self.conditionMet) {
-                                if (!self.branchHasExecuted) self.branchHasExecuted = true
-                                const result = (value as Function).apply(target, args)
-                                self.currentResult = result
-                                if (result instanceof UIRectangle) {
-                                    self.parentRectangle = result
-                                }
-                            }
-                            return self.createProxy()
-                        }
-                    }
+                // Case B: It's a property (getter)
+                // Accessing a property acts as a transition (e.g. accessing .lastElement)
+                if (self.conditionMet) {
+                    self.currentResult = value
                 }
                 
-                return (target as any)[prop]
+                return self.createProxy()
             }
         }) as any
     }
@@ -1209,6 +1157,7 @@ class UIRectangleConditionalBlock {
     getProxy(): UIRectangleConditionalChain<any, any> {
         return this.createProxy()
     }
+    
 }
 
 

package/scripts/UIView.ts

@@ -5,7 +5,21 @@ import { UICore } from "./UICore"
 import "./UICoreExtensions"
 import type { UIDialogView } from "./UIDialogView"
 import { UILocalizedTextObject } from "./UIInterfaces"
-import { FIRST, FIRST_OR_NIL, IF, IS, IS_DEFINED, IS_NIL, IS_NOT, nil, NO, RETURNER, UIObject, YES } from "./UIObject"
+import {
+    FIRST,
+    FIRST_OR_NIL,
+    IF,
+    IS,
+    IS_DEFINED,
+    IS_NIL,
+    IS_NOT,
+    IS_NOT_LIKE_NULL,
+    nil,
+    NO,
+    RETURNER,
+    UIObject,
+    YES
+} from "./UIObject"
 import { UIPoint } from "./UIPoint"
 import { UIRectangle } from "./UIRectangle"
 import { UIViewController } from "./UIViewController"
@@ -642,13 +656,17 @@ export class UIView extends UIObject {
     }
     
     
-    set hoverText(hoverText: string) {
-        this.viewHTMLElement.setAttribute("title", hoverText)
+    set hoverText(hoverText: string | undefined | null) {
+        if (IS_NOT_LIKE_NULL(hoverText)) {
+            this.viewHTMLElement.setAttribute("title", hoverText)
+        }
+        else {
+            this.viewHTMLElement.removeAttribute("title")
+        }
     }
     
-    
     get hoverText() {
-        return this.viewHTMLElement.getAttribute("title") ?? ""
+        return this.viewHTMLElement.getAttribute("title")
     }