wuira 0.3.0 → 0.3.2

package/lib/ui/layout/calculateFlow.lua

@@ -1,62 +1,169 @@
 --[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
 -- Lua Library inline imports
-local function __TS__NumberIsFinite(value)
-    return type(value) == "number" and value == value and value ~= math.huge and value ~= -math.huge
+local function __TS__StringIncludes(self, searchString, position)
+    if not position then
+        position = 1
+    else
+        position = position + 1
+    end
+    local index = string.find(self, searchString, position, true)
+    return index ~= nil
+end
+
+local function __TS__ArrayMap(self, callbackfn, thisArg)
+    local result = {}
+    for i = 1, #self do
+        result[i] = callbackfn(thisArg, self[i], i - 1, self)
+    end
+    return result
 end
 -- End of Lua Library inline imports
 local ____exports = {}
---- Pure layout calculation in top-left UI coordinates.
-function ____exports.calculateFlow(self, props, children)
-    local horizontal = props.direction == "horizontal"
-    local requestedLimit = horizontal and props.width or props.height
-    local limit = props.sizing == "content" and requestedLimit == 0 and math.huge or requestedLimit
+local function axisFraction(self, anchor, axis, fallback)
+    if anchor == nil or anchor == "" then
+        return fallback
+    end
+    if axis == "x" then
+        if __TS__StringIncludes(anchor, "LEFT") then
+            return 0
+        end
+        if __TS__StringIncludes(anchor, "RIGHT") then
+            return 1
+        end
+        return 0.5
+    end
+    if __TS__StringIncludes(anchor, "TOP") then
+        return 0
+    end
+    if __TS__StringIncludes(anchor, "BOTTOM") then
+        return 1
+    end
+    return 0.5
+end
+--- Horizontal space is columnGap. Vertical space is rowGap. Older gap and lineGap fill whichever axis is unset.
+function ____exports.flowSpacing(self, direction, props)
+    local horizontal = direction == "horizontal" or direction == "ltr" or direction == "rtl" or direction == "horizontalReverse"
     local gap = props.gap or 0
     local lineGap = props.lineGap or gap
-    if gap < 0 or lineGap < 0 then
+    local column = props.columnGap or (horizontal and gap or lineGap)
+    local row = props.rowGap or (horizontal and lineGap or gap)
+    if column < 0 or row < 0 then
         error("FlowLayout gaps must be non-negative")
     end
-    local result = {}
-    local cursor = 0
-    local cross = 0
-    local lineSize = 0
-    local count = 0
-    local lineStart = 0
-    local function alignLine()
-        local free = __TS__NumberIsFinite(limit) and math.max(0, limit - cursor) or 0
-        local offset = props.justify == "center" and free / 2 or (props.justify == "end" and free or 0)
-        do
-            local index = lineStart
-            while index < #result do
-                if horizontal then
-                    local ____result_index_0, ____x_1 = result[index + 1], "x"
-                    ____result_index_0[____x_1] = ____result_index_0[____x_1] + offset
-                else
-                    local ____result_index_2, ____y_3 = result[index + 1], "y"
-                    ____result_index_2[____y_3] = ____result_index_2[____y_3] + offset
-                end
-                index = index + 1
+    return horizontal and ({main = column, cross = row}) or ({main = row, cross = column})
+end
+local function flowAxis(self, direction)
+    local horizontal = direction == "horizontal" or direction == "ltr" or direction == "rtl" or direction == "horizontalReverse"
+    local reverse = direction == "rtl" or direction == "btt" or direction == "horizontalReverse" or direction == "verticalReverse"
+    return {horizontal = horizontal, reverse = reverse}
+end
+local function fraction(self, value, center, ____end)
+    if value == center then
+        return 0.5
+    end
+    if value == ____end then
+        return 1
+    end
+    return 0
+end
+--- Pack children along one direction, then place the group and each child separately.
+function ____exports.calculateFlow(self, props, children)
+    local ____flowAxis_result_0 = flowAxis(nil, props.direction)
+    local horizontal = ____flowAxis_result_0.horizontal
+    local reverse = ____flowAxis_result_0.reverse
+    local requestedLimit = horizontal and props.width or props.height
+    local limit = props.sizing == "content" and requestedLimit == 0 and math.huge or requestedLimit
+    local spacing = ____exports.flowSpacing(nil, props.direction, props)
+    local gap = spacing.main
+    local lineGap = spacing.cross
+    local justifyFallback = horizontal and props.alignX == nil or not horizontal and props.alignY == nil
+    local ____justifyFallback_1
+    if justifyFallback then
+        ____justifyFallback_1 = props.justify
+    else
+        ____justifyFallback_1 = nil
+    end
+    local mainJustify = ____justifyFallback_1
+    local alignX = fraction(nil, props.alignX or (horizontal and mainJustify == "center" and "center" or (horizontal and mainJustify == "end" and "right" or nil)), "center", "right")
+    local alignY = fraction(nil, props.alignY or (not horizontal and mainJustify == "center" and "center" or (not horizontal and mainJustify == "end" and "bottom" or nil)), "center", "bottom")
+    local lines = {}
+    local line = {items = {}, mainSize = 0, crossSize = 0}
+    do
+        local index = 0
+        while index < #children do
+            local child = children[index + 1]
+            local mainSize = horizontal and child.width or child.height
+            local crossSize = horizontal and child.height or child.width
+            local next = #line.items == 0 and 0 or line.mainSize + gap
+            if props.grow and #line.items > 0 and next + mainSize > limit then
+                lines[#lines + 1] = line
+                line = {items = {}, mainSize = 0, crossSize = 0}
+            end
+            local main = #line.items == 0 and 0 or line.mainSize + gap
+            local ____line_items_2 = line.items
+            ____line_items_2[#____line_items_2 + 1] = {
+                index = index,
+                main = main,
+                mainSize = mainSize,
+                crossSize = crossSize,
+                width = child.width,
+                height = child.height,
+                anchor = child.anchor
+            }
+            line.mainSize = main + mainSize
+            line.crossSize = math.max(line.crossSize, crossSize)
+            index = index + 1
+        end
+    end
+    if #line.items > 0 then
+        lines[#lines + 1] = line
+    end
+    local packCross = 0
+    local packMain = 0
+    do
+        local index = 0
+        while index < #lines do
+            packMain = math.max(packMain, lines[index + 1].mainSize)
+            packCross = packCross + lines[index + 1].crossSize
+            if index < #lines - 1 then
+                packCross = packCross + lineGap
             end
+            index = index + 1
         end
-        lineStart = #result
-    end
-    for ____, child in ipairs(children) do
-        local size = horizontal and child.width or child.height
-        local crossSize = horizontal and child.height or child.width
-        local next = count == 0 and 0 or cursor + gap
-        if props.grow and count > 0 and next + size > limit then
-            alignLine(nil)
-            cross = cross + (lineSize + lineGap)
-            cursor = 0
-            lineSize = 0
-            count = 0
+    end
+    local mainBox = horizontal and (props.sizing == "content" and props.width == 0 and packMain or props.width) or (props.sizing == "content" and props.height == 0 and packMain or props.height)
+    local crossBox = horizontal and (props.sizing == "content" and props.height == 0 and packCross or props.height) or (props.sizing == "content" and props.width == 0 and packCross or props.width)
+    local mainFraction = horizontal and alignX or alignY
+    local crossFraction = horizontal and alignY or alignX
+    local result = __TS__ArrayMap(
+        children,
+        function() return {x = 0, y = 0} end
+    )
+    local cross = (crossBox - packCross) * crossFraction
+    do
+        local index = 0
+        while index < #lines do
+            local packed = lines[index + 1]
+            local mainFree = mainBox - packed.mainSize
+            local mainShift = (justifyFallback and math.max(0, mainFree) or mainFree) * mainFraction
+            for ____, item in ipairs(packed.items) do
+                local main = (reverse and packed.mainSize - item.main - item.mainSize or item.main) + mainShift
+                local slotX = horizontal and main or cross
+                local slotY = horizontal and cross or main
+                local slotW = horizontal and item.mainSize or packed.crossSize
+                local slotH = horizontal and packed.crossSize or item.mainSize
+                result[item.index + 1] = {
+                    x = slotX + (slotW - item.width) * axisFraction(nil, item.anchor, "x", 0),
+                    y = slotY + (slotH - item.height) * axisFraction(nil, item.anchor, "y", 0)
+                }
+            end
+            cross = cross + packed.crossSize
+            if index < #lines - 1 then
+                cross = cross + lineGap
+            end
+            index = index + 1
         end
-        local position = count == 0 and 0 or cursor + gap
-        result[#result + 1] = horizontal and ({x = position, y = cross}) or ({x = cross, y = position})
-        cursor = position + size
-        lineSize = math.max(lineSize, crossSize)
-        count = count + 1
     end
-    alignLine(nil)
     return result
 end
 return ____exports

package/lib/ui/layout/calculateGrid.d.ts

@@ -1,9 +1,10 @@
 import type { GridLayoutProps } from "../GridLayout";
-/** Row-major placement into uniform slots; children keep their own sizes. */
-export declare function calculateGrid(props: GridLayoutProps, children: readonly {
-    width: number;
-    height: number;
-}[]): {
+import type { FlowChild } from "./calculateFlow";
+/** Place children in slots. Direction chooses the order; each child anchors inside its slot. */
+export declare function calculateGrid(props: GridLayoutProps & {
+    width?: number;
+    height?: number;
+}, children: readonly FlowChild[]): {
     x: number;
     y: number;
 }[];

package/lib/ui/layout/calculateGrid.lua

@@ -1,5 +1,15 @@
 --[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
 -- Lua Library inline imports
+local function __TS__StringIncludes(self, searchString, position)
+    if not position then
+        position = 1
+    else
+        position = position + 1
+    end
+    local index = string.find(self, searchString, position, true)
+    return index ~= nil
+end
+
 local function __TS__NumberIsFinite(value)
     return type(value) == "number" and value == value and value ~= math.huge and value ~= -math.huge
 end
@@ -13,7 +23,37 @@ local function __TS__ArrayMap(self, callbackfn, thisArg)
 end
 -- End of Lua Library inline imports
 local ____exports = {}
---- Row-major placement into uniform slots; children keep their own sizes.
+local function axisFraction(self, anchor, axis, fallback)
+    if anchor == nil or anchor == "" then
+        return fallback
+    end
+    if axis == "x" then
+        if __TS__StringIncludes(anchor, "LEFT") then
+            return 0
+        end
+        if __TS__StringIncludes(anchor, "RIGHT") then
+            return 1
+        end
+        return 0.5
+    end
+    if __TS__StringIncludes(anchor, "TOP") then
+        return 0
+    end
+    if __TS__StringIncludes(anchor, "BOTTOM") then
+        return 1
+    end
+    return 0.5
+end
+local function fraction(self, value, ____end)
+    if value == "center" then
+        return 0.5
+    end
+    if value == ____end then
+        return 1
+    end
+    return 0
+end
+--- Place children in slots. Direction chooses the order; each child anchors inside its slot.
 function ____exports.calculateGrid(self, props, children)
     if not __TS__NumberIsFinite(props.columns) or props.columns < 1 or math.floor(props.columns) ~= props.columns then
         error("GridLayout columns must be a positive integer")
@@ -36,12 +76,46 @@ function ____exports.calculateGrid(self, props, children)
     if width < 0 or height < 0 then
         error("GridLayout cell sizes must be non-negative")
     end
-    return __TS__ArrayMap(
+    local columns = props.columns
+    local rows = #children == 0 and 0 or math.ceil(#children / columns)
+    local vertical = props.direction == "ttb" or props.direction == "btt" or props.direction == "vertical" or props.direction == "verticalReverse"
+    local reverse = props.direction == "rtl" or props.direction == "btt" or props.direction == "horizontalReverse" or props.direction == "verticalReverse"
+    local alignX = fraction(nil, props.alignX, "right")
+    local alignY = fraction(nil, props.alignY, "bottom")
+    local points = __TS__ArrayMap(
         children,
-        function(____, _, index) return {
-            x = index % props.columns * (width + columnGap),
-            y = math.floor(index / props.columns) * (height + rowGap)
-        } end
+        function(____, child, index)
+            local column = index % columns
+            local row = math.floor(index / columns)
+            if vertical then
+                column = math.floor(index / math.max(1, rows))
+                row = index % math.max(1, rows)
+            end
+            if reverse then
+                if vertical then
+                    row = rows - 1 - row
+                else
+                    column = columns - 1 - column
+                end
+            end
+            local slotX = column * (width + columnGap)
+            local slotY = row * (height + rowGap)
+            return {
+                x = slotX + (width - child.width) * axisFraction(nil, child.anchor, "x", 0),
+                y = slotY + (height - child.height) * axisFraction(nil, child.anchor, "y", 0)
+            }
+        end
     )
+    local packW = (columns == 0 or rows == 0) and 0 or columns * width + math.max(0, columns - 1) * columnGap
+    local packH = (columns == 0 or rows == 0) and 0 or rows * height + math.max(0, rows - 1) * rowGap
+    local boxW = props.sizing == "content" and (props.width or 0) == 0 and packW or (props.width or packW)
+    local boxH = props.sizing == "content" and (props.height or 0) == 0 and packH or (props.height or packH)
+    local shiftX = (boxW - packW) * alignX
+    local shiftY = (boxH - packH) * alignY
+    for ____, point in ipairs(points) do
+        point.x = point.x + shiftX
+        point.y = point.y + shiftY
+    end
+    return points
 end
 return ____exports

package/lib/ui/layout/measureLayout.lua

@@ -4,6 +4,14 @@ local function __TS__NumberIsFinite(value)
     return type(value) == "number" and value == value and value ~= math.huge and value ~= -math.huge
 end
 
+local function __TS__ArrayMap(self, callbackfn, thisArg)
+    local result = {}
+    for i = 1, #self do
+        result[i] = callbackfn(thisArg, self[i], i - 1, self)
+    end
+    return result
+end
+
 local function __TS__ArrayIncludes(self, searchElement, fromIndex)
     if fromIndex == nil then
         fromIndex = 0
@@ -51,14 +59,6 @@ local function __TS__SparseArraySpread(sparseArray)
     return _unpack(sparseArray, 1, sparseArray.sparseLength)
 end
 
-local function __TS__ArrayMap(self, callbackfn, thisArg)
-    local result = {}
-    for i = 1, #self do
-        result[i] = callbackfn(thisArg, self[i], i - 1, self)
-    end
-    return result
-end
-
 local function __TS__ObjectAssign(target, ...)
     local sources = {...}
     for i = 1, #sources do
@@ -73,15 +73,20 @@ local function __TS__ObjectAssign(target, ...)
 end
 -- End of Lua Library inline imports
 local ____exports = {}
+local resolveSize, flowMainHorizontal, measureChildren
 local ____Spacing = require("types.Spacing")
 local resolveSpacing = ____Spacing.resolveSpacing
 local ____calculateFlow = require("ui.layout.calculateFlow")
 local calculateFlow = ____calculateFlow.calculateFlow
+local flowSpacing = ____calculateFlow.flowSpacing
 local ____calculateGrid = require("ui.layout.calculateGrid")
 local calculateGrid = ____calculateGrid.calculateGrid
-local function resolveSize(self, value, available, margin)
-    if value == "inherit" then
+function resolveSize(self, value, available, margin)
+    if value == "inherit" or value == "fill" then
         if available == nil then
+            if value == "fill" then
+                return 0
+            end
             error("Cannot inherit a size from an unconstrained content-sized parent")
         end
         return math.max(0, available - margin)
@@ -91,6 +96,72 @@ local function resolveSize(self, value, available, margin)
     end
     return value
 end
+function flowMainHorizontal(self, direction)
+    return direction == "horizontal" or direction == "ltr" or direction == "rtl" or direction == "horizontalReverse"
+end
+function measureChildren(self, layout, sourceChildren, contentWidth, contentHeight, path)
+    local box = {width = contentWidth, height = contentHeight}
+    if layout == nil or layout.kind ~= "flow" then
+        return __TS__ArrayMap(
+            sourceChildren,
+            function(____, child) return ____exports.measureLayout(nil, child, box, path) end
+        )
+    end
+    local horizontal = flowMainHorizontal(nil, layout.props.direction)
+    local gap = flowSpacing(nil, layout.props.direction, layout.props).main
+    local measured = {}
+    local fillIndexes = {}
+    do
+        local index = 0
+        while index < #sourceChildren do
+            local child = sourceChildren[index + 1]
+            if (horizontal and child.props.width or child.props.height) == "fill" then
+                fillIndexes[#fillIndexes + 1] = index
+            else
+                measured[index + 1] = ____exports.measureLayout(nil, child, box, path)
+            end
+            index = index + 1
+        end
+    end
+    local used = 0
+    do
+        local index = 0
+        while index < #measured do
+            do
+                local __continue16
+                repeat
+                    local child = measured[index + 1]
+                    if child == nil then
+                        __continue16 = true
+                        break
+                    end
+                    used = used + (horizontal and child.width + child.margin.left + child.margin.right or child.height + child.margin.top + child.margin.bottom)
+                    __continue16 = true
+                until true
+                if not __continue16 then
+                    break
+                end
+            end
+            index = index + 1
+        end
+    end
+    local ____horizontal_0
+    if horizontal then
+        ____horizontal_0 = contentWidth
+    else
+        ____horizontal_0 = contentHeight
+    end
+    local contentMain = ____horizontal_0
+    local leftover = contentMain == nil and 0 or math.max(
+        0,
+        contentMain - used - math.max(0, #sourceChildren - 1) * gap
+    )
+    local share = #fillIndexes == 0 and 0 or leftover / #fillIndexes
+    for ____, index in ipairs(fillIndexes) do
+        measured[index + 1] = ____exports.measureLayout(nil, sourceChildren[index + 1], horizontal and ({width = share, height = contentHeight}) or ({width = contentWidth, height = share}), path)
+    end
+    return measured
+end
 --- Resolve available space top-down and content bounds bottom-up.
 function ____exports.measureLayout(self, element, available, ancestors)
     if available == nil then
@@ -123,20 +194,20 @@ function ____exports.measureLayout(self, element, available, ancestors)
     local isLayout = element.kind == "flow" or element.kind == "grid"
     local layout = isLayout and element or nil
     local contentSizing = (layout and layout.props.sizing) == "content"
-    local ____temp_2
+    local ____temp_3
     if contentSizing and props.width == 0 then
-        ____temp_2 = nil
+        ____temp_3 = nil
     else
-        ____temp_2 = math.max(0, width - padding.left - padding.right)
+        ____temp_3 = math.max(0, width - padding.left - padding.right)
     end
-    local contentWidth = ____temp_2
-    local ____temp_3
+    local contentWidth = ____temp_3
+    local ____temp_4
     if contentSizing and props.height == 0 then
-        ____temp_3 = nil
+        ____temp_4 = nil
     else
-        ____temp_3 = math.max(0, height - padding.top - padding.bottom)
+        ____temp_4 = math.max(0, height - padding.top - padding.bottom)
     end
-    local contentHeight = ____temp_3
+    local contentHeight = ____temp_4
     local sourceChildren = layout ~= nil and layout.children or (cell.child == nil and ({}) or ({cell.child}))
     local childWidth = contentWidth
     local childHeight = contentHeight
@@ -149,47 +220,55 @@ function ____exports.measureLayout(self, element, available, ancestors)
             1,
             math.ceil(#sourceChildren / grid.columns)
         )
-        local ____grid_cellWidth_7 = grid.cellWidth
-        if ____grid_cellWidth_7 == nil then
-            local ____temp_6
+        local ____grid_cellWidth_8 = grid.cellWidth
+        if ____grid_cellWidth_8 == nil then
+            local ____temp_7
             if contentWidth == nil then
-                ____temp_6 = nil
+                ____temp_7 = nil
             else
-                ____temp_6 = math.max(0, (contentWidth - (grid.columnGap or grid.gap or 0) * (grid.columns - 1)) / grid.columns)
+                ____temp_7 = math.max(0, (contentWidth - (grid.columnGap or grid.gap or 0) * (grid.columns - 1)) / grid.columns)
             end
-            ____grid_cellWidth_7 = ____temp_6
+            ____grid_cellWidth_8 = ____temp_7
         end
-        childWidth = ____grid_cellWidth_7
-        local ____grid_cellHeight_9 = grid.cellHeight
-        if ____grid_cellHeight_9 == nil then
-            local ____temp_8
+        childWidth = ____grid_cellWidth_8
+        local ____grid_cellHeight_10 = grid.cellHeight
+        if ____grid_cellHeight_10 == nil then
+            local ____temp_9
             if contentHeight == nil then
-                ____temp_8 = nil
+                ____temp_9 = nil
             else
-                ____temp_8 = math.max(0, (contentHeight - (grid.rowGap or grid.gap or 0) * (rows - 1)) / rows)
+                ____temp_9 = math.max(0, (contentHeight - (grid.rowGap or grid.gap or 0) * (rows - 1)) / rows)
             end
-            ____grid_cellHeight_9 = ____temp_8
+            ____grid_cellHeight_10 = ____temp_9
         end
-        childHeight = ____grid_cellHeight_9
+        childHeight = ____grid_cellHeight_10
     end
-    local ____array_10 = __TS__SparseArrayNew(__TS__Unpack(ancestors))
-    __TS__SparseArrayPush(____array_10, element)
-    local path = {__TS__SparseArraySpread(____array_10)}
-    local children = __TS__ArrayMap(
+    local ____array_11 = __TS__SparseArrayNew(__TS__Unpack(ancestors))
+    __TS__SparseArrayPush(____array_11, element)
+    local path = {__TS__SparseArraySpread(____array_11)}
+    local children = measureChildren(
+        nil,
+        layout,
         sourceChildren,
-        function(____, child) return ____exports.measureLayout(nil, child, {width = childWidth, height = childHeight}, path) end
+        childWidth,
+        childHeight,
+        path
     )
     local placements
     if layout ~= nil then
         local sizes = __TS__ArrayMap(
             children,
-            function(____, child) return {width = child.width + child.margin.left + child.margin.right, height = child.height + child.margin.top + child.margin.bottom} end
+            function(____, child) return {width = child.width + child.margin.left + child.margin.right, height = child.height + child.margin.top + child.margin.bottom, anchor = child.cell.props.anchor} end
         )
         local positions = layout.kind == "flow" and calculateFlow(
             nil,
             __TS__ObjectAssign({}, layout.props, {width = contentWidth or 0, height = contentHeight or 0}),
             sizes
-        ) or calculateGrid(nil, layout.props, sizes)
+        ) or calculateGrid(
+            nil,
+            __TS__ObjectAssign({}, layout.props, {width = contentWidth or 0, height = contentHeight or 0}),
+            sizes
+        )
         placements = __TS__ArrayMap(
             positions,
             function(____, point) return {x = point.x + padding.left, y = point.y + padding.top} end