@slowclap/rezi-core 0.1.0-fork.1

package/dist/renderer/renderToDrawlist/simpleVNode.js

@@ -0,0 +1,770 @@
+import { getSpinnerFrame, resolveIconGlyph as resolveIconRenderGlyph, } from "../../icons/index.js";
+import { measureTextCells, truncateMiddle, truncateStart, truncateWithEllipsis, } from "../../layout/textMeasure.js";
+import { resolveColor } from "../../theme/theme.js";
+import { badgeRecipe, tagRecipe } from "../../ui/recipes.js";
+import { renderShadow, resolveBoxShadowConfig } from "../shadow.js";
+import { asTextStyle, getButtonLabelStyle } from "../styles.js";
+import { readBoxBorder, renderBoxBorder } from "./boxBorder.js";
+import { readIntNonNegative, resolveMarginFromProps, resolveSpacingFromProps } from "./spacing.js";
+import { mergeTextStyle, shouldFillForStyleOverride } from "./textStyle.js";
+import { getColorTokens } from "./themeTokens.js";
+function clamp01(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    if (value <= 0)
+        return 0;
+    if (value >= 1)
+        return 1;
+    return value;
+}
+function readString(v) {
+    return typeof v === "string" ? v : undefined;
+}
+function readNumber(v) {
+    if (typeof v !== "number" || !Number.isFinite(v))
+        return undefined;
+    return v;
+}
+function readNonNegativeInt(v) {
+    const n = readNumber(v);
+    if (n === undefined || n < 0)
+        return undefined;
+    return Math.trunc(n);
+}
+function readTextOverflow(v) {
+    switch (v) {
+        case "ellipsis":
+        case "middle":
+        case "start":
+            return v;
+        default:
+            return "clip";
+    }
+}
+function textVariantToStyle(variant) {
+    switch (variant) {
+        case "heading":
+        case "label":
+            return { bold: true };
+        case "caption":
+            return { dim: true };
+        case "code":
+            return { inverse: true };
+        default:
+            return undefined;
+    }
+}
+function truncateToWidth(text, width) {
+    if (width <= 0 || text.length === 0)
+        return "";
+    return measureTextCells(text) > width ? truncateWithEllipsis(text, width) : text;
+}
+function variantToThemeColor(theme, variant, fallback) {
+    switch (variant) {
+        case "primary":
+            return theme.colors.primary;
+        case "success":
+            return theme.colors.success;
+        case "warning":
+            return theme.colors.warning;
+        case "error":
+            return theme.colors.danger;
+        case "info":
+            return theme.colors.info;
+        default:
+            return theme.colors[fallback] ?? theme.colors.primary;
+    }
+}
+function variantToRecipeTone(variant) {
+    switch (variant) {
+        case "success":
+            return "success";
+        case "warning":
+            return "warning";
+        case "error":
+            return "danger";
+        case "info":
+            return "info";
+        case "primary":
+            return "primary";
+        default:
+            return "default";
+    }
+}
+function resolveChipColor(theme, variant, kind) {
+    const colorTokens = getColorTokens(theme);
+    if (colorTokens !== null) {
+        const tone = variantToRecipeTone(variant);
+        const bgStyle = (kind === "badge" ? badgeRecipe(colorTokens, { tone }).bg : tagRecipe(colorTokens, { tone }).bg);
+        if (typeof bgStyle.bg === "number") {
+            return bgStyle.bg;
+        }
+    }
+    const fallbackTone = kind === "badge" || variant === "primary" ? "primary" : "secondary";
+    return variantToThemeColor(theme, variant, fallbackTone);
+}
+function statusToThemeColor(theme, status) {
+    switch (status) {
+        case "online":
+            return theme.colors.success;
+        case "offline":
+            return theme.colors.danger;
+        case "away":
+            return theme.colors.warning;
+        case "busy":
+            return theme.colors.danger;
+        default:
+            return theme.colors.muted;
+    }
+}
+function readSpinnerVariant(v) {
+    switch (v) {
+        case "dots":
+        case "line":
+        case "circle":
+        case "bounce":
+        case "pulse":
+        case "arrows":
+        case "dots2":
+            return v;
+        default:
+            return "dots";
+    }
+}
+function resolveIconText(iconPath, fallback) {
+    return resolveIconRenderGlyph(iconPath, fallback).glyph;
+}
+function clipSegmentsToWidth(segments, maxWidth) {
+    if (maxWidth <= 0)
+        return [];
+    const out = [];
+    let remaining = maxWidth;
+    for (const segment of segments) {
+        if (segment.text.length === 0 || remaining <= 0)
+            continue;
+        const width = measureTextCells(segment.text);
+        if (width <= remaining) {
+            out.push(segment);
+            remaining -= width;
+            continue;
+        }
+        const clipped = truncateToWidth(segment.text, remaining);
+        if (clipped.length > 0)
+            out.push({ text: clipped, style: segment.style });
+        break;
+    }
+    return out;
+}
+function isAsciiText(text) {
+    for (let i = 0; i < text.length; i++) {
+        const c = text.charCodeAt(i);
+        if (c < 0x20 || c > 0x7e)
+            return false;
+    }
+    return true;
+}
+function containsNonAsciiSegment(segments) {
+    for (const segment of segments) {
+        if (!isAsciiText(segment.text))
+            return true;
+    }
+    return false;
+}
+function drawSegments(builder, x, y, maxWidth, segments, options = {}) {
+    const textRunStableKey = (segments0) => JSON.stringify(segments0.map((segment) => [segment.text, segment.style ?? null]));
+    const clipped = clipSegmentsToWidth(segments, maxWidth);
+    if (clipped.length === 0)
+        return;
+    if (clipped.length === 1) {
+        const first = clipped[0];
+        if (!first)
+            return;
+        builder.drawText(x, y, first.text, first.style);
+        return;
+    }
+    if (options.preferDrawText !== true) {
+        const blobIndex = builder.addTextRunBlob(clipped.map((segment) => ({
+            text: segment.text,
+            style: segment.style,
+        })));
+        if (blobIndex !== null) {
+            builder.drawTextRun(x, y, blobIndex);
+            return;
+        }
+    }
+    let cursorX = x;
+    for (const segment of clipped) {
+        builder.drawText(cursorX, y, segment.text, segment.style);
+        cursorX += measureTextCells(segment.text);
+    }
+}
+const SIMPLE_VNODE_MEASURE_MAX_DEPTH = 64;
+function measureVNodeSimpleHeightInternal(vnode, w, depth) {
+    if (depth > SIMPLE_VNODE_MEASURE_MAX_DEPTH)
+        return 1;
+    if (w <= 0)
+        return 1;
+    switch (vnode.kind) {
+        case "row":
+        case "column": {
+            const props = vnode.props;
+            const spacing = resolveSpacingFromProps(props);
+            const margin = resolveMarginFromProps(props);
+            const gap = readIntNonNegative(props.gap, 0);
+            const stackW = Math.max(0, w - margin.left - margin.right);
+            const innerW = Math.max(0, stackW - spacing.left - spacing.right);
+            const children = vnode.children.filter((c) => c !== null && c !== undefined);
+            if (children.length === 0) {
+                return Math.max(1, margin.top + margin.bottom + spacing.top + spacing.bottom);
+            }
+            if (vnode.kind === "row") {
+                let maxChildHeight = 1;
+                for (const child of children) {
+                    maxChildHeight = Math.max(maxChildHeight, measureVNodeSimpleHeightInternal(child, innerW, depth + 1));
+                }
+                return Math.max(1, margin.top + margin.bottom + spacing.top + spacing.bottom + maxChildHeight);
+            }
+            let total = 0;
+            for (const child of children) {
+                total += measureVNodeSimpleHeightInternal(child, innerW, depth + 1);
+            }
+            total += gap * Math.max(0, children.length - 1);
+            return Math.max(1, margin.top + margin.bottom + spacing.top + spacing.bottom + total);
+        }
+        case "box": {
+            const props = vnode.props;
+            const spacing = resolveSpacingFromProps(props);
+            const margin = resolveMarginFromProps(props);
+            const border = readBoxBorder(props.border);
+            const defaultSide = border !== "none";
+            const borderTop = typeof props.borderTop === "boolean" ? props.borderTop : defaultSide;
+            const borderRight = typeof props.borderRight === "boolean" ? props.borderRight : defaultSide;
+            const borderBottom = typeof props.borderBottom === "boolean" ? props.borderBottom : defaultSide;
+            const borderLeft = typeof props.borderLeft === "boolean" ? props.borderLeft : defaultSide;
+            const bt = border === "none" || !borderTop ? 0 : 1;
+            const br = border === "none" || !borderRight ? 0 : 1;
+            const bb = border === "none" || !borderBottom ? 0 : 1;
+            const bl = border === "none" || !borderLeft ? 0 : 1;
+            const boxW = Math.max(0, w - margin.left - margin.right);
+            const innerW = Math.max(0, boxW - bl - br - spacing.left - spacing.right);
+            let childTotal = 0;
+            for (const child of vnode.children) {
+                childTotal += measureVNodeSimpleHeightInternal(child, innerW, depth + 1);
+            }
+            return Math.max(1, margin.top + margin.bottom + bt + bb + spacing.top + spacing.bottom + childTotal);
+        }
+        default:
+            return 1;
+    }
+}
+/**
+ * Measure the minimum height needed to render a VNode using simple virtual-list rendering.
+ */
+export function measureVNodeSimpleHeight(vnode, w) {
+    return measureVNodeSimpleHeightInternal(vnode, Math.max(0, Math.trunc(w)), 0);
+}
+/**
+ * Simple VNode renderer for virtual list items.
+ * This renders a VNode at the given position without going through the full layout system.
+ */
+export function renderVNodeSimple(builder, vnode, x, y, w, h, focused, tick, theme, inheritedStyle) {
+    if (h <= 0 || w <= 0)
+        return;
+    switch (vnode.kind) {
+        case "text": {
+            const props = vnode.props;
+            const variantStyle = textVariantToStyle(props.variant);
+            const ownStyle = asTextStyle(props.style, theme);
+            const style = variantStyle === undefined && ownStyle === undefined
+                ? inheritedStyle
+                : mergeTextStyle(mergeTextStyle(inheritedStyle, variantStyle), ownStyle);
+            const textOverflow = readTextOverflow(props.textOverflow);
+            const maxWidth = readNonNegativeInt(props.maxWidth);
+            const overflowW = maxWidth === undefined ? w : Math.min(w, maxWidth);
+            if (overflowW <= 0)
+                break;
+            let displayText = vnode.text;
+            if (measureTextCells(displayText) > overflowW) {
+                switch (textOverflow) {
+                    case "ellipsis":
+                        displayText = truncateWithEllipsis(displayText, overflowW);
+                        break;
+                    case "middle":
+                        displayText = truncateMiddle(displayText, overflowW);
+                        break;
+                    case "start":
+                        displayText = truncateStart(displayText, overflowW);
+                        break;
+                    case "clip":
+                        break;
+                }
+            }
+            builder.pushClip(x, y, overflowW, h);
+            builder.drawText(x, y, displayText, style);
+            builder.popClip();
+            break;
+        }
+        case "button": {
+            const props = vnode.props;
+            const label = typeof props.label === "string" ? props.label : "";
+            const disabled = props.disabled === true;
+            const ownStyle = asTextStyle(props.style, theme);
+            builder.pushClip(x, y, w, h);
+            builder.drawText(x + 1, y, label, mergeTextStyle(mergeTextStyle(inheritedStyle, ownStyle), getButtonLabelStyle({ focused, disabled })));
+            builder.popClip();
+            break;
+        }
+        case "input": {
+            const props = vnode.props;
+            const value = typeof props.value === "string" ? props.value : "";
+            const disabled = props.disabled === true;
+            const ownStyle = asTextStyle(props.style, theme);
+            builder.pushClip(x, y, w, h);
+            builder.drawText(x + 1, y, value, mergeTextStyle(mergeTextStyle(inheritedStyle, ownStyle), getButtonLabelStyle({ focused, disabled })));
+            builder.popClip();
+            break;
+        }
+        case "icon": {
+            const props = vnode.props;
+            const iconPath = readString(props.icon) ?? "";
+            const ownStyle = asTextStyle(props.style, theme);
+            const style = mergeTextStyle(inheritedStyle, ownStyle);
+            const glyph = resolveIconText(iconPath, props.fallback === true);
+            builder.pushClip(x, y, w, h);
+            const display = truncateToWidth(glyph, w);
+            if (display.length > 0)
+                builder.drawText(x, y, display, style);
+            builder.popClip();
+            break;
+        }
+        case "spinner": {
+            const props = vnode.props;
+            const variant = readSpinnerVariant(props.variant);
+            const label = readString(props.label);
+            const ownStyle = asTextStyle(props.style, theme);
+            const style = mergeTextStyle(inheritedStyle, ownStyle);
+            const frameStyle = mergeTextStyle(style, { fg: theme.colors.primary, bold: true });
+            const frame = getSpinnerFrame(variant, tick);
+            builder.pushClip(x, y, w, h);
+            drawSegments(builder, x, y, w, label && label.length > 0
+                ? [
+                    { text: frame, style: frameStyle },
+                    { text: ` ${label}`, style },
+                ]
+                : [{ text: frame, style: frameStyle }]);
+            builder.popClip();
+            break;
+        }
+        case "richText": {
+            const props = vnode.props;
+            const spans = Array.isArray(props.spans)
+                ? props.spans
+                : [];
+            if (spans.length === 0)
+                break;
+            const segments = [];
+            for (const span of spans) {
+                const text = readString(span.text) ?? "";
+                if (text.length === 0)
+                    continue;
+                segments.push({
+                    text,
+                    style: mergeTextStyle(inheritedStyle, asTextStyle(span.style, theme)),
+                });
+            }
+            if (segments.length === 0)
+                break;
+            builder.pushClip(x, y, w, h);
+            drawSegments(builder, x, y, w, segments);
+            builder.popClip();
+            break;
+        }
+        case "badge": {
+            const props = vnode.props;
+            const text = readString(props.text) ?? "";
+            const ownStyle = asTextStyle(props.style, theme);
+            const color = resolveChipColor(theme, props.variant, "badge");
+            const style = mergeTextStyle(mergeTextStyle(inheritedStyle, { fg: color, bold: true }), ownStyle);
+            const content = truncateToWidth(`( ${text} )`, w);
+            if (shouldFillForStyleOverride(ownStyle)) {
+                builder.fillRect(x, y, w, h, style);
+            }
+            builder.pushClip(x, y, w, h);
+            if (content.length > 0) {
+                builder.drawText(x, y, content, style);
+            }
+            builder.popClip();
+            break;
+        }
+        case "kbd": {
+            const props = vnode.props;
+            const keys = props.keys;
+            const separator = readString(props.separator) ?? "+";
+            const ownStyle = asTextStyle(props.style, theme);
+            const style = mergeTextStyle(inheritedStyle, ownStyle);
+            const keyStyle = mergeTextStyle(style, { bold: true });
+            const mutedStyle = mergeTextStyle(keyStyle, { fg: theme.colors.muted });
+            const segments = [];
+            if (typeof keys === "string") {
+                segments.push({ text: "[", style: mutedStyle });
+                segments.push({ text: keys, style: keyStyle });
+                segments.push({ text: "]", style: mutedStyle });
+            }
+            else if (Array.isArray(keys)) {
+                for (let i = 0; i < keys.length; i++) {
+                    const key = keys[i];
+                    if (typeof key !== "string")
+                        continue;
+                    if (i > 0)
+                        segments.push({ text: separator, style: mutedStyle });
+                    segments.push({ text: "[", style: mutedStyle });
+                    segments.push({ text: key, style: keyStyle });
+                    segments.push({ text: "]", style: mutedStyle });
+                }
+            }
+            builder.pushClip(x, y, w, h);
+            drawSegments(builder, x, y, w, segments, {
+                preferDrawText: containsNonAsciiSegment(segments),
+            });
+            builder.popClip();
+            break;
+        }
+        case "status": {
+            const props = vnode.props;
+            const label = readString(props.label);
+            const showLabel = props.showLabel === true || (props.showLabel !== false && label !== undefined);
+            const ownStyle = asTextStyle(props.style, theme);
+            const style = mergeTextStyle(inheritedStyle, ownStyle);
+            const dotStyle = mergeTextStyle(style, {
+                fg: statusToThemeColor(theme, props.status),
+                bold: true,
+            });
+            const segments = [{ text: "●", style: dotStyle }];
+            if (showLabel && label && label.length > 0) {
+                segments.push({ text: ` ${label}`, style });
+            }
+            builder.pushClip(x, y, w, h);
+            drawSegments(builder, x, y, w, segments);
+            builder.popClip();
+            break;
+        }
+        case "tag": {
+            const props = vnode.props;
+            const text = readString(props.text) ?? "";
+            const removable = props.removable === true;
+            const ownStyle = asTextStyle(props.style, theme);
+            const variantColor = resolveChipColor(theme, props.variant, "tag");
+            const tagStyle = mergeTextStyle(mergeTextStyle(inheritedStyle, { fg: variantColor, bold: true }), ownStyle);
+            const content = truncateToWidth(`( ${text}${removable ? " ×" : ""} )`, w);
+            if (shouldFillForStyleOverride(ownStyle)) {
+                builder.fillRect(x, y, w, h, tagStyle);
+            }
+            builder.pushClip(x, y, w, h);
+            if (content.length > 0) {
+                builder.drawText(x, y, content, tagStyle);
+            }
+            builder.popClip();
+            break;
+        }
+        case "progress": {
+            const props = vnode.props;
+            const value = clamp01(readNumber(props.value) ?? 0);
+            const label = readString(props.label) ?? "";
+            const showPercent = props.showPercent === true;
+            const ownStyle = asTextStyle(props.style, theme);
+            const style = mergeTextStyle(inheritedStyle, ownStyle);
+            const variant = props.variant === "blocks" ? "blocks" : props.variant === "minimal" ? "minimal" : "bar";
+            const labelText = label.length > 0 ? `${label} ` : "";
+            const percentText = showPercent ? ` ${Math.round(value * 100)}%` : "";
+            const explicitWidth = typeof props.width === "number" && Number.isFinite(props.width) && props.width > 0
+                ? Math.trunc(props.width)
+                : undefined;
+            let barWidth = explicitWidth ??
+                Math.max(1, w - measureTextCells(labelText) - measureTextCells(percentText));
+            if (variant !== "minimal")
+                barWidth = Math.max(3, barWidth);
+            const fillGlyph = variant === "minimal" ? "━" : variant === "blocks" ? "▓" : "█";
+            const emptyGlyph = variant === "minimal" ? "╌" : "░";
+            const fillStyle = mergeTextStyle(style, { fg: theme.colors.primary, bold: true });
+            const trackStyle = mergeTextStyle(mergeTextStyle(style, { fg: theme.colors.muted }), asTextStyle(props.trackStyle, theme));
+            const segments = [];
+            if (labelText.length > 0)
+                segments.push({ text: labelText, style });
+            if (variant === "minimal") {
+                const filled = Math.max(0, Math.min(barWidth, Math.round(barWidth * value)));
+                const empty = Math.max(0, barWidth - filled);
+                if (filled > 0)
+                    segments.push({ text: fillGlyph.repeat(filled), style: fillStyle });
+                if (empty > 0)
+                    segments.push({ text: emptyGlyph.repeat(empty), style: trackStyle });
+            }
+            else {
+                const inner = Math.max(1, barWidth - 2);
+                const filled = Math.max(0, Math.min(inner, Math.round(inner * value)));
+                const empty = Math.max(0, inner - filled);
+                segments.push({ text: "[", style });
+                if (filled > 0)
+                    segments.push({ text: fillGlyph.repeat(filled), style: fillStyle });
+                if (empty > 0)
+                    segments.push({ text: emptyGlyph.repeat(empty), style: trackStyle });
+                segments.push({ text: "]", style });
+            }
+            if (percentText.length > 0)
+                segments.push({ text: percentText, style });
+            builder.pushClip(x, y, w, h);
+            drawSegments(builder, x, y, w, segments);
+            builder.popClip();
+            break;
+        }
+        case "spacer": {
+            // Spacers are invisible, nothing to render
+            break;
+        }
+        case "row":
+        case "column": {
+            // Render children in a minimal stack layout (used for virtual list items).
+            const props = vnode.props;
+            const spacing = resolveSpacingFromProps(props);
+            const margin = resolveMarginFromProps(props);
+            const gap = readIntNonNegative(props.gap, 0);
+            const ownStyle = asTextStyle(props.style, theme);
+            const style = mergeTextStyle(inheritedStyle, ownStyle);
+            const stackX = x + margin.left;
+            const stackY = y + margin.top;
+            const stackW = Math.max(0, w - margin.left - margin.right);
+            const stackH = Math.max(0, h - margin.top - margin.bottom);
+            if (shouldFillForStyleOverride(ownStyle)) {
+                builder.fillRect(stackX, stackY, stackW, stackH, style);
+            }
+            const ix = stackX + spacing.left;
+            const iy = stackY + spacing.top;
+            const iw = Math.max(0, stackW - spacing.left - spacing.right);
+            const ih = Math.max(0, stackH - spacing.top - spacing.bottom);
+            builder.pushClip(ix, iy, iw, ih);
+            const children = vnode.children.filter((c) => c !== null && c !== undefined);
+            const estimateChildWidth = (child) => {
+                switch (child.kind) {
+                    case "text":
+                        return measureTextCells(child.text);
+                    case "richText": {
+                        const p = child.props;
+                        const spans = Array.isArray(p.spans) ? p.spans : [];
+                        let total = 0;
+                        for (const span of spans) {
+                            const text = typeof span.text === "string" ? span.text : "";
+                            total += measureTextCells(text);
+                        }
+                        return total;
+                    }
+                    case "button": {
+                        const p = child.props;
+                        const label = typeof p.label === "string" ? p.label : "";
+                        return measureTextCells(label) + 2; // +1 left padding +1 slack
+                    }
+                    case "input": {
+                        const p = child.props;
+                        const value = typeof p.value === "string" ? p.value : "";
+                        return measureTextCells(value) + 2; // +1 left padding +1 slack
+                    }
+                    case "divider":
+                        return 1;
+                    case "icon":
+                        return 1;
+                    case "spinner": {
+                        const p = child.props;
+                        const label = typeof p.label === "string" ? p.label : "";
+                        return Math.max(1, measureTextCells(label) + (label.length > 0 ? 2 : 1));
+                    }
+                    case "badge": {
+                        const p = child.props;
+                        const text = typeof p.text === "string" ? p.text : "";
+                        return measureTextCells(`( ${text} )`);
+                    }
+                    case "tag": {
+                        const p = child.props;
+                        const text = typeof p.text === "string" ? p.text : "";
+                        const suffix = p.removable === true ? " ×" : "";
+                        return measureTextCells(`( ${text}${suffix} )`);
+                    }
+                    case "status": {
+                        const p = child.props;
+                        const label = typeof p.label === "string" ? p.label : undefined;
+                        const showLabel = p.showLabel === true || (p.showLabel !== false && label !== undefined);
+                        return 1 + (showLabel && label ? measureTextCells(label) + 1 : 0);
+                    }
+                    case "kbd": {
+                        const p = child.props;
+                        const sep = typeof p.separator === "string" ? p.separator : "+";
+                        if (typeof p.keys === "string")
+                            return measureTextCells(p.keys) + 2;
+                        if (!Array.isArray(p.keys))
+                            return 0;
+                        let total = 0;
+                        for (let i = 0; i < p.keys.length; i++) {
+                            const key = p.keys[i];
+                            if (typeof key !== "string")
+                                continue;
+                            total += measureTextCells(key) + 2;
+                            if (i > 0)
+                                total += measureTextCells(sep);
+                        }
+                        return total;
+                    }
+                    case "progress": {
+                        const p = child.props;
+                        const explicit = typeof p.width === "number" && Number.isFinite(p.width) && p.width > 0
+                            ? Math.trunc(p.width)
+                            : 10;
+                        const label = typeof p.label === "string" ? p.label : "";
+                        const percent = p.showPercent === true ? 5 : 0;
+                        return explicit + (label.length > 0 ? measureTextCells(label) + 1 : 0) + percent;
+                    }
+                    case "spacer": {
+                        const p = child.props;
+                        const size = typeof p.size === "number" && Number.isFinite(p.size) ? p.size : 0;
+                        return Math.max(0, Math.floor(size));
+                    }
+                    default:
+                        return 0;
+                }
+            };
+            if (vnode.kind === "row") {
+                const limitX = ix + iw;
+                const count = children.length;
+                let cursorX = ix;
+                for (let i = 0; i < count; i++) {
+                    const child = children[i];
+                    if (!child)
+                        continue;
+                    if (cursorX >= limitX)
+                        break;
+                    const remaining = limitX - cursorX;
+                    const gapsRemaining = gap * Math.max(0, count - i - 1);
+                    const available = Math.max(0, remaining - gapsRemaining);
+                    const childW = i === count - 1
+                        ? remaining
+                        : Math.max(0, Math.min(available, estimateChildWidth(child)));
+                    renderVNodeSimple(builder, child, cursorX, iy, childW, ih, focused, tick, theme, style);
+                    cursorX += childW;
+                    if (i < count - 1)
+                        cursorX += gap;
+                }
+            }
+            else {
+                const limitY = iy + ih;
+                const count = children.length;
+                let cursorY = iy;
+                for (let i = 0; i < count; i++) {
+                    const child = children[i];
+                    if (!child)
+                        continue;
+                    if (cursorY >= limitY)
+                        break;
+                    const remaining = limitY - cursorY;
+                    const measuredChildH = measureVNodeSimpleHeight(child, iw);
+                    const childH = Math.min(remaining, measuredChildH);
+                    renderVNodeSimple(builder, child, ix, cursorY, iw, childH, focused, tick, theme, style);
+                    cursorY += childH;
+                    if (i < count - 1)
+                        cursorY += gap;
+                }
+            }
+            builder.popClip();
+            break;
+        }
+        case "divider": {
+            const props = vnode.props;
+            const direction = props.direction === "vertical" ? "vertical" : "horizontal";
+            const rawChar = typeof props.char === "string" && props.char.length > 0 ? props.char : undefined;
+            const glyph = (() => {
+                const fallback = direction === "horizontal" ? "─" : "│";
+                if (!rawChar)
+                    return fallback;
+                const cp = rawChar.codePointAt(0);
+                return cp === undefined ? fallback : String.fromCodePoint(cp);
+            })();
+            const label = typeof props.label === "string" ? props.label : undefined;
+            const color = typeof props.color === "string" ? props.color : undefined;
+            const style = color
+                ? mergeTextStyle(inheritedStyle, { fg: resolveColor(theme, color) })
+                : inheritedStyle;
+            if (direction === "horizontal") {
+                if (w <= 0 || h <= 0)
+                    break;
+                const lineY = y;
+                if (label && label.length > 0) {
+                    const labelText = ` ${label} `;
+                    const labelWidth = measureTextCells(labelText);
+                    if (labelWidth >= w) {
+                        builder.drawText(x, lineY, truncateToWidth(labelText, w), style);
+                        break;
+                    }
+                    const remaining = w - labelWidth;
+                    const left = Math.floor(remaining / 2);
+                    const right = remaining - left;
+                    builder.drawText(x, lineY, `${glyph.repeat(left)}${labelText}${glyph.repeat(right)}`, style);
+                    break;
+                }
+                builder.drawText(x, lineY, glyph.repeat(w), style);
+                break;
+            }
+            for (let i = 0; i < h; i++) {
+                builder.drawText(x, y + i, glyph, style);
+            }
+            break;
+        }
+        case "box": {
+            const props = vnode.props;
+            const spacing = resolveSpacingFromProps(props);
+            const margin = resolveMarginFromProps(props);
+            const border = readBoxBorder(props.border);
+            const defaultSide = border !== "none";
+            const borderTop = typeof props.borderTop === "boolean" ? props.borderTop : defaultSide;
+            const borderRight = typeof props.borderRight === "boolean" ? props.borderRight : defaultSide;
+            const borderBottom = typeof props.borderBottom === "boolean" ? props.borderBottom : defaultSide;
+            const borderLeft = typeof props.borderLeft === "boolean" ? props.borderLeft : defaultSide;
+            const title = typeof props.title === "string" ? props.title : undefined;
+            const ownStyle = asTextStyle(props.style, theme);
+            const borderOwnStyle = asTextStyle(props.borderStyle, theme);
+            const contentStyle = mergeTextStyle(inheritedStyle, ownStyle);
+            const borderRenderStyle = borderOwnStyle === undefined
+                ? contentStyle
+                : mergeTextStyle(inheritedStyle, borderOwnStyle);
+            const boxX = x + margin.left;
+            const boxY = y + margin.top;
+            const boxW = Math.max(0, w - margin.left - margin.right);
+            const boxH = Math.max(0, h - margin.top - margin.bottom);
+            const shadowConfig = resolveBoxShadowConfig(props.shadow, theme.colors.border);
+            if (shadowConfig) {
+                renderShadow(builder, { x: boxX, y: boxY, w: boxW, h: boxH }, shadowConfig, borderRenderStyle);
+            }
+            if (shouldFillForStyleOverride(ownStyle)) {
+                builder.fillRect(boxX, boxY, boxW, boxH, contentStyle);
+            }
+            renderBoxBorder(builder, { x: boxX, y: boxY, w: boxW, h: boxH }, border, title, "left", borderRenderStyle, { top: borderTop, right: borderRight, bottom: borderBottom, left: borderLeft });
+            const bt = border === "none" || !borderTop ? 0 : 1;
+            const br = border === "none" || !borderRight ? 0 : 1;
+            const bb = border === "none" || !borderBottom ? 0 : 1;
+            const bl = border === "none" || !borderLeft ? 0 : 1;
+            const cx = boxX + bl + spacing.left;
+            const cy = boxY + bt + spacing.top;
+            const cw = Math.max(0, boxW - bl - br - spacing.left - spacing.right);
+            const ch = Math.max(0, boxH - bt - bb - spacing.top - spacing.bottom);
+            builder.pushClip(cx, cy, cw, ch);
+            let cursorY = cy;
+            for (const child of vnode.children) {
+                if (cursorY >= cy + ch)
+                    break;
+                const childH = Math.min(ch - (cursorY - cy), measureVNodeSimpleHeight(child, cw));
+                renderVNodeSimple(builder, child, cx, cursorY, cw, childH, focused, tick, theme, contentStyle);
+                cursorY += childH;
+            }
+            builder.popClip();
+            break;
+        }
+        default:
+            // Other kinds: spacer, input, focusZone, focusTrap, virtualList - skip or minimal render
+            break;
+    }
+}
+//# sourceMappingURL=simpleVNode.js.map