uicore-ts 1.1.59 → 1.1.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uicore-ts",
-  "version": "1.1.59",
+  "version": "1.1.62",
   "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/UIRectangle.ts

@@ -712,6 +712,145 @@ export class UIRectangle extends UIObject {
         
     }
     
+    /**
+     * Distributes views vertically as a column, returning their calculated frames.
+     * Each view is positioned below the previous one with optional padding between them.
+     * @param views - Array of views to distribute
+     * @param paddings - Padding between views (single value or array of values)
+     * @param absoluteHeights - Optional fixed heights for views (overrides intrinsic height)
+     * @returns Array of rectangles representing the frame for each view
+     */
+    framesByDistributingViewsAsColumn(
+        views: UIView[],
+        paddings: SizeNumberOrFunctionOrView | SizeNumberOrFunctionOrView[] = 0,
+        absoluteHeights: SizeNumberOrFunctionOrView | SizeNumberOrFunctionOrView[] = nil
+    ) {
+        const frames: UIRectangle[] = []
+        let currentRectangle = this.copy()
+        
+        if (!(paddings instanceof Array)) {
+            paddings = [paddings].arrayByRepeating(views.length - 1)
+        }
+        paddings = paddings.map(padding => this._heightNumberFromSizeNumberOrFunctionOrView(padding))
+        
+        if (!(absoluteHeights instanceof Array) && IS_NOT_NIL(absoluteHeights)) {
+            absoluteHeights = [absoluteHeights].arrayByRepeating(views.length)
+        }
+        absoluteHeights = absoluteHeights.map(
+            height => this._heightNumberFromSizeNumberOrFunctionOrView(height)
+        )
+        
+        for (let i = 0; i < views.length; i++) {
+            const frame = currentRectangle.rectangleWithIntrinsicContentHeightForView(views[i])
+            
+            if (IS_NOT_NIL(absoluteHeights[i])) {
+                frame.height = absoluteHeights[i] as number
+            }
+            
+            frames.push(frame)
+            
+            const padding = (paddings[i] || 0) as number
+            currentRectangle = frame.rectangleForNextRow(padding)
+        }
+        
+        return frames
+    }
+    
+    /**
+     * Distributes views horizontally as a row, returning their calculated frames.
+     * Each view is positioned to the right of the previous one with optional padding between them.
+     * @param views - Array of views to distribute
+     * @param paddings - Padding between views (single value or array of values)
+     * @param absoluteWidths - Optional fixed widths for views (overrides intrinsic width)
+     * @returns Array of rectangles representing the frame for each view
+     */
+    framesByDistributingViewsAsRow(
+        views: UIView[],
+        paddings: SizeNumberOrFunctionOrView | SizeNumberOrFunctionOrView[] = 0,
+        absoluteWidths: SizeNumberOrFunctionOrView | SizeNumberOrFunctionOrView[] = nil
+    ) {
+        const frames: UIRectangle[] = []
+        let currentRectangle = this.copy()
+        
+        if (!(paddings instanceof Array)) {
+            paddings = [paddings].arrayByRepeating(views.length - 1)
+        }
+        paddings = paddings.map(padding => this._widthNumberFromSizeNumberOrFunctionOrView(padding))
+        
+        if (!(absoluteWidths instanceof Array) && IS_NOT_NIL(absoluteWidths)) {
+            absoluteWidths = [absoluteWidths].arrayByRepeating(views.length)
+        }
+        absoluteWidths = absoluteWidths.map(
+            width => this._widthNumberFromSizeNumberOrFunctionOrView(width)
+        )
+        
+        for (let i = 0; i < views.length; i++) {
+            const frame = currentRectangle.rectangleWithIntrinsicContentWidthForView(views[i])
+            
+            if (IS_NOT_NIL(absoluteWidths[i])) {
+                frame.width = absoluteWidths[i] as number
+            }
+            
+            frames.push(frame)
+            
+            const padding = (paddings[i] || 0) as number
+            currentRectangle = frame.rectangleForNextColumn(padding)
+        }
+        
+        return frames
+    }
+    
+    /**
+     * Distributes views as a grid (2D array), returning their calculated frames.
+     * The first index represents rows (vertical), the second index represents columns (horizontal).
+     * Example: views[0] is the first row, views[0][0] is the first column in the first row.
+     * Each row is laid out horizontally, and rows are stacked vertically.
+     * @param views - 2D array where views[row][column] represents the grid structure
+     * @param paddings - Vertical padding between rows (single value or array of values)
+     * @param absoluteHeights - Optional fixed heights for each row (overrides intrinsic height)
+     * @returns 2D array of rectangles where frames[row][column] matches views[row][column]
+     */
+    framesByDistributingViewsAsGrid(
+        views: UIView[][],
+        paddings: SizeNumberOrFunctionOrView | SizeNumberOrFunctionOrView[] = 0,
+        absoluteHeights: SizeNumberOrFunctionOrView | SizeNumberOrFunctionOrView[] = nil
+    ) {
+        const frames: UIRectangle[][] = []
+        let currentRowRectangle = this.copy()
+        
+        if (!(paddings instanceof Array)) {
+            paddings = [paddings].arrayByRepeating(views.length - 1)
+        }
+        paddings = paddings.map(padding => this._heightNumberFromSizeNumberOrFunctionOrView(padding))
+        
+        if (!(absoluteHeights instanceof Array) && IS_NOT_NIL(absoluteHeights)) {
+            absoluteHeights = [absoluteHeights].arrayByRepeating(views.length)
+        }
+        absoluteHeights = absoluteHeights.map(
+            height => this._heightNumberFromSizeNumberOrFunctionOrView(height)
+        )
+        
+        for (let i = 0; i < views.length; i++) {
+            const rowViews = views[i]
+            const rowFrames = currentRowRectangle.framesByDistributingViewsAsRow(rowViews)
+            
+            if (IS_NOT_NIL(absoluteHeights[i])) {
+                const heightNumber = absoluteHeights[i] as number
+                rowFrames.forEach(frame => {
+                    frame.height = heightNumber
+                })
+            }
+            
+            frames.push(rowFrames)
+            
+            const padding = (paddings[i] || 0) as number
+            const maxHeight = Math.max(...rowFrames.map(f => f.height))
+            currentRowRectangle = currentRowRectangle.rectangleForNextRow(padding, maxHeight)
+        }
+        
+        return frames
+    }
+    
     rectangleWithIntrinsicContentSizeForView(view: UIView, centeredOnXPosition = 0, centeredOnYPosition = 0) {
         const intrinsicContentSize = view.intrinsicContentSize()
         return this.rectangleWithHeight(intrinsicContentSize.height, centeredOnYPosition)

package/scripts/UIView.ts

@@ -1950,7 +1950,10 @@ export class UIView extends UIObject {
     
     removeFromSuperview() {
         if (IS(this.superview)) {
-            this.forEachViewInSubtree(view => view.blur())
+            this.forEachViewInSubtree(view => {
+                view.blur()
+                view.cancelNeedsLayout()
+            })
             this.cancelNeedsLayout()
             const index = this.superview.subviews.indexOf(this)
             if (index > -1) {