@jimka/typescript-ui 0.2.0 → 0.3.0

package/dist/lib/VBox-EIqw85Rh.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"VBox-EIqw85Rh.js","names":[],"sources":["../../src/typescript/lib/layout/VBox.ts"],"sourcesContent":["// SPDX-License-Identifier: PolyForm-Noncommercial-1.0.0\n\nimport { FillType } from \"~/layout/FillType.js\";\nimport { Size, UNBOUNDED, isUnbounded } from \"~/primitive/Size.js\";\nimport { Insets } from \"~/primitive/Insets.js\";\nimport { Component } from \"~/core/Component.js\";\nimport { BoxLayout, BoxLayoutOptions } from \"~/layout/BoxLayout.js\";\nimport { callable } from \"~/core/Callable.js\";\n\n/**\n * Construction-time options for {@link VBox}.\n *\n * @remarks `mode` selects the sizing strategy along the vertical axis.\n * `\"preferred\"` (the default) honours each child's preferred height and\n * supports `weight` cells. `\"equal\"` divides the container height equally\n * and ignores `weight`. `mode` is independent of `stretching` (the cross-axis\n * fill): `stretching` defaults to `false` in both modes, so `\"equal\"` divides\n * the height but leaves children at their preferred width unless\n * `stretching: true` is passed.\n *\n * @category Layouts\n */\nexport interface VBoxOptions extends BoxLayoutOptions {}\n\n/**\n * A layout manager that places children in a single vertical column. The\n * `mode` option selects between preferred-height sequencing (with weight-cell\n * support) and equal-height division of the container.\n *\n * @category Layouts\n */\nclass VBox extends BoxLayout {\n\n    private _defaultComponentHeight: number = 100;\n\n    /**\n     * Returns the column's baseline — the first laid-out child's baseline,\n     * measured from the container's content-top — so a baseline-aware parent\n     * aligns this VBox container by its first row's text baseline rather than\n     * auto-centring the whole container.\n     *\n     * @returns The first child's baseline offset in pixels, or `null` when there\n     * is no container, no laid-out children, or the first child reports no\n     * baseline of its own.\n     *\n     * @remarks Forwards the **first** child's baseline verbatim — unlike\n     * {@link HBox}, which takes the maximum baseline across the row's children.\n     * A column has a single well-defined first row, so forwarding it (including\n     * a `null` when that first row is graphical) is the most predictable\n     * contract. The first child stacks at the container's content-top in every\n     * mode, so its own baseline is already content-relative — `Component`'s\n     * `getBaseline` then adds the container's chrome. Unlike `HBox`, this is not\n     * disabled while stretching: VBox `stretching` fills the cross (width) axis\n     * and leaves each child's height and intrinsic baseline untouched.\n     */\n    getContentBaseline(): number | null {\n        const container = this.getContainer();\n        if (!container) {\n            return null;\n        }\n\n        const components = container.getLaidOutComponents();\n        if (components.length === 0) {\n            return null;\n        }\n\n        return components[0].getBaseline();\n    }\n\n    /**\n     * Returns the preferred size. In `\"preferred\"` mode this is the widest\n     * child width and the sum of child heights plus spacing. In `\"equal\"`\n     * mode height is `count * (maxChildHeight + spacing) - spacing`.\n     *\n     * @returns The preferred `{width, height}`, or `null` if no container is attached.\n     */\n    getPreferredSize(): Size | null {\n        let container = this.getContainer();\n        if (!container) {\n            return null;\n        }\n\n        let perimeterSize = container.getPerimeterSize();\n        let components = container.getLaidOutComponents();\n\n        if (this._mode === \"equal\") {\n            let innerWidth = 0;\n            let innerHeight = 0;\n\n            for (let idx in components) {\n                let component = components[idx];\n                let size = component.getPreferredSize();\n\n                if (size) {\n                    innerWidth  = Math.max(innerWidth,  size.width);\n                    innerHeight = Math.max(innerHeight, size.height);\n                }\n            }\n\n            const width  = innerWidth + perimeterSize.left + perimeterSize.right;\n            const height = components.length * (innerHeight + this._spacing) - this._spacing\n                         + perimeterSize.top + perimeterSize.bottom;\n\n            return { width, height };\n        }\n\n        let width = UNBOUNDED;\n        let height = perimeterSize.top + perimeterSize.bottom;\n\n        for (let idx in components) {\n            let component = components[idx];\n            let size = component.getPreferredSize();\n\n            if (size) {\n                width = isUnbounded(width) ? Math.min(width, size.width) : Math.max(width, size.width);\n                height += size.height;\n            }\n        }\n\n        width += perimeterSize.left + perimeterSize.right;\n        height += this._spacing * (components.length - 1);\n\n        return {\n            width: width,\n            height: height\n        };\n    }\n\n    /**\n     * Returns the minimum size. In `\"preferred\"` mode this is the widest\n     * child minimum width and the sum of child minimum heights plus\n     * spacing. In `\"equal\"` mode height is\n     * `count * (maxChildMinHeight + spacing) - spacing`.\n     *\n     * @returns The minimum `{width, height}`, or `null` if no container is attached.\n     */\n    getMinSize(): Size | null {\n        let container = this.getContainer();\n        if (!container) {\n            return null;\n        }\n\n        let perimeterSize = container.getPerimeterSize();\n        let components = container.getLaidOutComponents();\n\n        if (this._mode === \"equal\") {\n            let innerWidth = 0;\n            let innerHeight = 0;\n\n            for (let idx in components) {\n                let component = components[idx];\n                let size = component.getMinSize();\n\n                if (size) {\n                    innerWidth  = Math.max(innerWidth,  size.width);\n                    innerHeight = Math.max(innerHeight, size.height);\n                }\n            }\n\n            const width  = innerWidth + perimeterSize.left + perimeterSize.right;\n            const height = components.length * (innerHeight + this._spacing) - this._spacing\n                         + perimeterSize.top + perimeterSize.bottom;\n\n            return { width, height };\n        }\n\n        let width = 0;\n        let height = perimeterSize.top + perimeterSize.bottom;\n\n        for (let idx in components) {\n            let component = components[idx];\n            let size = component.getMinSize();\n\n            if (size) {\n                width = Math.max(width, size.width);\n                height += size.height;\n            }\n        }\n\n        width += perimeterSize.left + perimeterSize.right;\n        height += this._spacing * (components.length - 1);\n\n        return {\n            width: width,\n            height: height\n        };\n    }\n\n    /**\n     * Returns the maximum size the column can usefully occupy. Along the main\n     * axis (height) it sums the children's *maximum* heights plus spacing; in\n     * `\"equal\"` mode it is `count * maxChildMaxHeight` plus spacing, since every\n     * cell shares the tallest child's allowance. The cross axis (width) takes\n     * the *largest* child maximum — the widest a child permits the column to\n     * grow to. A child whose maximum is `null` or at the unbounded sentinel\n     * makes that axis unbounded.\n     *\n     * @returns The maximum `{width, height}`, or `null` if no container is attached.\n     */\n    getMaxSize(): Size | null {\n        return this.aggregateMaxSize(false);\n    }\n\n    /**\n     * Computes the children's combined minSize along this manager's geometry.\n     * In `\"preferred\"` mode height is the sum of per-child `minSize.height`\n     * plus spacing. In `\"equal\"` mode height is\n     * `count * maxChildMinHeight + spacing*(n-1)` (VBox distributes height\n     * equally so the per-cell floor is the max of every child's min height).\n     * Width in both modes is the max per-child `minSize.width`. Used by\n     * `doLayout` to inflate the working size when the host has opted into\n     * `setOverflowing` on the corresponding axis.\n     *\n     * @returns The total min-size; `{ width: 0, height: 0 }` when the\n     *   container is absent or has no children.\n     */\n    protected computeTotalMinSize(): Size {\n        const container = this.getContainer();\n        if (!container) {\n            return { width: 0, height: 0 };\n        }\n\n        const components = container.getLaidOutComponents();\n        if (components.length === 0) {\n            return { width: 0, height: 0 };\n        }\n\n        let width = 0;\n\n        if (this._mode === \"equal\") {\n            let maxHeight = 0;\n\n            for (const component of components) {\n                const min = component.getMinSize();\n                if (min) {\n                    width     = Math.max(width,     min.width);\n                    maxHeight = Math.max(maxHeight, min.height);\n                }\n            }\n\n            return {\n                width,\n                height: components.length * (maxHeight + this._spacing) - this._spacing,\n            };\n        }\n\n        let height = this._spacing * (components.length - 1);\n\n        for (const component of components) {\n            const min = component.getMinSize();\n            if (min) {\n                width   = Math.max(width, min.width);\n                height += min.height;\n            }\n        }\n\n        return { width, height };\n    }\n\n    /**\n     * Lays out the children top-to-bottom, dispatching to `layoutEqualMode` or\n     * `layoutPreferredMode` per the sizing mode after inflating the working\n     * size for any scroll-enabled axis.\n     */\n    doLayout(): void {\n        const container = this.getContainer();\n        if (!container) {\n            return;\n        }\n\n        const innerSize = container.getInnerSize();\n        if (!innerSize) {\n            return;\n        }\n\n        const components      = container.getLaidOutComponents();\n        const containerInsets = container.getContentInsets();\n        const spacing         = this.getComponentSpacing();\n\n        // Universal scroll: when the host has opted into per-axis overflow, lay\n        // out against the children's combined minSize so trailing children land\n        // past the viewport and the host's CSS `overflow: auto` scrolls.\n        // `innerSize` stays the real viewport for equal mode's overflow test.\n        const containerSize = this.inflateForOverflow(innerSize);\n\n        if (this._mode === \"equal\") {\n            this.layoutEqualMode(components, innerSize, containerSize, containerInsets, spacing);\n        } else {\n            this.layoutPreferredMode(components, containerSize, containerInsets, spacing);\n        }\n\n        this.reserveContentFrame();\n    }\n\n    /**\n     * Places children in equal-height cells stacked top-to-bottom. Every cell\n     * takes the same height (see {@link VBox.computeEqualCellHeight}); when\n     * stretching, cells fill the container width, otherwise children keep their\n     * preferred width and are left-aligned within the column.\n     *\n     * @param components - The children to place, in order.\n     * @param innerSize - The host's real inner size (pre-inflation), used to\n     *   measure the equal share against the true viewport.\n     * @param containerSize - The working size, possibly inflated for overflow.\n     * @param insets - The container's content insets.\n     * @param spacing - Inter-child spacing in pixels.\n     */\n    private layoutEqualMode(components: Component[], innerSize: Size, containerSize: Size, insets: Insets, spacing: number): void {\n        const cellHeight = this.computeEqualCellHeight(components, innerSize.height, spacing);\n\n        const x = insets.getLeft();\n        let y = insets.getTop();\n\n        if (this.isStretching()) {\n            const cellWidth = containerSize.width;\n\n            for (const component of components) {\n                this.placeComponent(component, x, y, cellWidth, cellHeight, FillType.BOTH);\n\n                y += cellHeight + spacing;\n            }\n\n            return;\n        }\n\n        // Match the equal-stretch band exactly: the stretch branch fills\n        // containerSize.width from insets.left with no right-inset subtraction,\n        // so an EAST/fill align-self child reaches the same trailing edge.\n        const crossLead   = insets.getLeft();\n        const crossExtent = containerSize.width;\n\n        for (const component of components) {\n            const size  = component.getPreferredSize();\n            const width = size ? size.width : 0;\n\n            const cross = this.crossPlacement(component, crossLead, crossExtent, width, false);\n\n            if (cross) {\n                this.placeComponent(component, cross.offset, y, cross.extent, cellHeight, FillType.BOTH);\n            } else {\n                this.placeComponent(component, x, y, width, cellHeight, FillType.BOTH);\n            }\n\n            y += cellHeight + spacing;\n        }\n    }\n\n    /**\n     * Computes the shared cell height for equal mode: the equal share of the\n     * inner height, floored at the tallest child's min height.\n     *\n     * @param components - The children sharing the column.\n     * @param innerHeight - The host's real inner height (pre-inflation).\n     * @param spacing - Inter-child spacing in pixels.\n     * @returns The height every equal-mode cell receives.\n     *\n     * @remarks Three cases drive the floor: (1) the share clears the tallest\n     * child's min height → the column fits, divide equally; (2) the share is\n     * below the min floor, the host scrolls on this axis, and `overflowSizing`\n     * is `\"preferred\"` → every cell takes the tallest child's preferred height\n     * so cells regain preferred size instead of sticking at min while\n     * scrolling; (3) otherwise → clamp to the min floor (a non-scrolling host's\n     * `overflow: hidden` clips the surplus).\n     */\n    private computeEqualCellHeight(components: Component[], innerHeight: number, spacing: number): number {\n        let maxChildMinHeight = 0;\n        let maxChildPreferredHeight = 0;\n\n        for (const component of components) {\n            const min = component.getMinSize();\n            if (min) {\n                maxChildMinHeight = Math.max(maxChildMinHeight, min.height);\n            }\n\n            const pref = component.getPreferredSize();\n            if (pref) {\n                maxChildPreferredHeight = Math.max(maxChildPreferredHeight, pref.height);\n            }\n        }\n\n        const equalShare = (innerHeight - spacing * (components.length - 1)) / components.length;\n\n        if (equalShare >= maxChildMinHeight) {\n            return equalShare;\n        }\n\n        if (this.isOverflowingY() && this._overflowSizing === \"preferred\") {\n            return Math.max(maxChildMinHeight, maxChildPreferredHeight);\n        }\n\n        return maxChildMinHeight;\n    }\n\n    /**\n     * Places children at their preferred heights stacked top-to-bottom. Weight\n     * cells split the space left after the non-weighted children; when the\n     * column overflows, the non-weighted children shrink proportionally toward\n     * their min heights. Children keep their preferred width, or fill the\n     * container width when stretching.\n     *\n     * @param components - The children to place, in order.\n     * @param containerSize - The working size, possibly inflated for overflow.\n     * @param insets - The container's content insets.\n     * @param spacing - Inter-child spacing in pixels.\n     */\n    private layoutPreferredMode(components: Component[], containerSize: Size, insets: Insets, spacing: number): void {\n        const { totalWeight, fixedPreferred, fixedMin } = this.measureFixedHeights(components, spacing);\n\n        const { remaining: remainingHeight, shrinkRatio } = this.computeShrink(\n            fixedPreferred,\n            fixedMin,\n            containerSize.height,\n            this.isOverflowingY()\n        );\n\n        // Pre-pass: resolve each child's height into an array so the trailing\n        // slack can be measured before placement (mirrors HBox's widths[]).\n        const heights: number[] = [];\n\n        for (const component of components) {\n            const weight  = this.getLayoutConstraints(component)?.weight ?? 0;\n            const size    = component.getPreferredSize();\n            const minSize = component.getMinSize();\n            const maxSize = component.getMaxSize();\n\n            heights.push(this.resolveChildHeight(size, minSize, maxSize, weight, totalWeight, remainingHeight, shrinkRatio));\n        }\n\n        // Sum the placed main extents to find the trailing slack, then ask the\n        // shared helper how to distribute it. Weight cells already consume all\n        // slack, so justify is a no-op when any are present.\n        let lead = 0;\n        let gap  = 0;\n\n        if (totalWeight === 0) {\n            let contentHeight = spacing * (components.length - 1);\n\n            for (const h of heights) {\n                contentHeight += h;\n            }\n\n            const innerHeight = containerSize.height - (insets.getTop() + insets.getBottom());\n\n            ({ lead, gap } = this.justifyOffsets(contentHeight, innerHeight, components.length));\n        }\n\n        // Cross band for per-child align-self: the horizontal band trimmed by\n        // both insets. The default path keeps reading containerSize.width\n        // (un-trimmed) to stay byte-identical with today's body.\n        const crossLead   = insets.getLeft();\n        const crossExtent = containerSize.width - (insets.getLeft() + insets.getRight());\n\n        const x = insets.getLeft();\n        let y = insets.getTop() + lead;\n\n        for (let idx = 0; idx < components.length; idx += 1) {\n            const component = components[idx];\n            const size    = component.getPreferredSize();\n            const maxSize = component.getMaxSize();\n\n            // Cross-axis (width): give the child the column's available width —\n            // the full inner width when stretching or sizeless, otherwise its\n            // preferred width capped to the column. Cap to the child's maximum,\n            // but do NOT floor to its minimum: enforcing the minimum here would\n            // dogmatically inflate a child back up to its content size even when\n            // the column is narrower, defeating a scrolling/clipping child. The\n            // child's own setWidth → clampWidth applies its minimum (its content\n            // minimum for a general component, or nothing for a Panel, which fits\n            // its allocation and scrolls). When the host opts into horizontal\n            // scroll, `containerSize` is already inflated to the content extent\n            // upstream, so `min(pref, containerSize)` still yields the full width\n            // without a floor here.\n            let defaultWidth: number;\n\n            if (!size || this.isStretching()) {\n                defaultWidth = containerSize.width;\n            } else {\n                defaultWidth = Math.min(size.width, containerSize.width);\n            }\n\n            if (maxSize) {\n                defaultWidth = Math.min(defaultWidth, maxSize.width);\n            }\n\n            // Align-self sizes from the child's *preferred* width (capped to the\n            // band + max), independent of global stretching, so an anchored child\n            // shrinks-and-anchors even when the column is stretching.\n            let naturalWidth = size ? Math.min(size.width, crossExtent) : crossExtent;\n\n            if (maxSize) {\n                naturalWidth = Math.min(naturalWidth, maxSize.width);\n            }\n\n            const cross = this.crossPlacement(component, crossLead, crossExtent, naturalWidth, false);\n\n            if (cross) {\n                this.placeComponent(component, cross.offset, y, cross.extent, heights[idx], FillType.BOTH);\n            } else {\n                this.placeComponent(component, x, y, defaultWidth, heights[idx], FillType.BOTH);\n            }\n\n            // Advance by the resolved height, not getHeight(): the gap is\n            // measured against the same extent contentHeight summed, so a\n            // placeComponent clamp must not skew the trailing edge.\n            y += heights[idx];\n            y += spacing + gap;\n        }\n    }\n\n    /**\n     * Sums the non-weighted children's preferred and minimum heights (each\n     * including inter-child spacing) and the total weight of the weight cells.\n     *\n     * @param components - The children sharing the column.\n     * @param spacing - Inter-child spacing in pixels.\n     * @returns `totalWeight` of the weight cells, plus the `fixedPreferred` and\n     *   `fixedMin` height totals of the non-weighted children.\n     */\n    private measureFixedHeights(components: Component[], spacing: number): { totalWeight: number; fixedPreferred: number; fixedMin: number } {\n        let totalWeight = 0;\n        let fixedPreferred = spacing * (components.length - 1);\n        let fixedMin       = spacing * (components.length - 1);\n\n        for (const component of components) {\n            const weight = this.getLayoutConstraints(component)?.weight ?? 0;\n\n            if (weight > 0) {\n                totalWeight += weight;\n            } else {\n                const size    = component.getPreferredSize();\n                const minSize = component.getMinSize();\n\n                fixedPreferred += this.preferredChildHeight(size, minSize);\n                fixedMin       += minSize ? minSize.height : 0;\n            }\n        }\n\n        return { totalWeight, fixedPreferred, fixedMin };\n    }\n\n    /**\n     * Resolves a non-weighted child's preferred height, falling back through min\n     * height to `_defaultComponentHeight`.\n     *\n     * @param size - The child's preferred size, or `null`.\n     * @param minSize - The child's minimum size, or `null`.\n     * @returns The height the child contributes before shrinking.\n     *\n     * @remarks Nullish-coalesce, not `||`: a component with an explicit\n     * preferred height of 0 must contribute 0, not fall through to\n     * `_defaultComponentHeight`. The `minSize.height > 0` guard prevents\n     * `LayoutManager._defaultMinSize = {0,0}` from short-circuiting the chain\n     * into a 0 height (which would land a layout-managed Table on a 0 height\n     * even though no preferred size was set).\n     *\n     * The result is floored at the child's own min height: a child placed at\n     * `max(preferred, min)` (see {@link VBox.resolveChildHeight}) must reserve\n     * that same height in the fixed total, or a child reporting `preferred < min`\n     * (a `min ≤ preferred` invariant violation) would be under-reserved and push\n     * the weighted cells out, overflowing the column.\n     */\n    private preferredChildHeight(size: Size | null, minSize: Size | null): number {\n        const preferred = (size ? size.height : undefined)\n            ?? (minSize && minSize.height > 0 ? minSize.height : undefined)\n            ?? this._defaultComponentHeight;\n\n        return minSize ? Math.max(preferred, minSize.height) : preferred;\n    }\n\n    /**\n     * Resolves a child's final height within the column, clamped to its\n     * min/max. Weight cells take a share of `remainingHeight`; non-weighted\n     * children take their preferred height reduced by the shrink ratio toward\n     * their min height.\n     *\n     * @param size - The child's preferred size, or `null`.\n     * @param minSize - The child's minimum size, or `null`.\n     * @param maxSize - The child's maximum size, or `null`.\n     * @param weight - The child's weight constraint (0 when non-weighted).\n     * @param totalWeight - The summed weight of all weight cells.\n     * @param remainingHeight - The space available to weight cells.\n     * @param shrinkRatio - How far (0–1) non-weighted children shrink to min.\n     * @returns The child's height.\n     */\n    private resolveChildHeight(size: Size | null, minSize: Size | null, maxSize: Size | null, weight: number, totalWeight: number, remainingHeight: number, shrinkRatio: number): number {\n        let height: number;\n\n        if (weight > 0 && totalWeight > 0) {\n            height = (weight / totalWeight) * remainingHeight;\n        } else {\n            const pref = this.preferredChildHeight(size, minSize);\n            const min  = minSize ? minSize.height : 0;\n\n            height = pref - shrinkRatio * (pref - min);\n        }\n\n        if (minSize) {\n            height = Math.max(height, minSize.height);\n        }\n\n        if (maxSize) {\n            height = Math.min(height, maxSize.height);\n        }\n\n        return height;\n    }\n}\n\nconst VBoxCallable = callable(VBox);\ntype VBoxCallable = VBox;\nexport {\n    VBox         as _VBox,\n    VBoxCallable as VBox\n};\n"],"mappings":"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"}