@zaly/tui 0.0.4

package/dist/box-DyaByEiG.mjs

@@ -0,0 +1,386 @@
+import { S as unwrap } from "./reactive-f7NpAi69.mjs";
+import { t as Node } from "./node-BZ7f6HzU.mjs";
+import { n as resolveSize, t as clamp } from "./size-D8JogYLy.mjs";
+import { a as zipRow, i as stackColumn, n as isFixedWidth, r as padRow, t as allocateRow } from "./flex-Bguo-fUe.mjs";
+import { textContent } from "./widgets/text.mjs";
+import { sliceAnsi, stringWidth } from "@zaly/shared/ansi";
+//#region src/layout/border.ts
+/** @internal */
+const borders = {
+	double: {
+		bl: "╚",
+		br: "╝",
+		h: "═",
+		tl: "╔",
+		tr: "╗",
+		v: "║"
+	},
+	rounded: {
+		bl: "╰",
+		br: "╯",
+		h: "─",
+		tl: "╭",
+		tr: "╮",
+		v: "│"
+	},
+	single: {
+		bl: "└",
+		br: "┘",
+		h: "─",
+		tl: "┌",
+		tr: "┐",
+		v: "│"
+	}
+};
+/** Resolve the `border` style value to a concrete BorderChars, or undefined.
+*
+* @internal*/
+function resolveBorder(spec) {
+	if (spec === void 0 || spec === false) return void 0;
+	if (spec === true) return borders.single;
+	if (typeof spec === "string") return borders[spec];
+	return spec;
+}
+/** Pass-through wrapper used when no style is supplied. */
+const identity = (s) => s;
+/**
+* Wrap pre-rendered inner rows with a border, adding top/bottom border rows
+* and left/right border chars to each inner row. Inner rows must be padded
+* to a uniform width; the output rows are `innerWidth + 2` wide.
+*
+* Border glyphs and the optional title can be styled independently via
+* `borderStyle` / `titleStyle` — each is a pre-bound `StyleBuilder`, so
+* this helper stays purely about geometry and never touches SGR itself.
+*
+* @internal
+*/
+function drawBorder(rows, chars, opts = {}) {
+	const { title, titleAlign } = opts;
+	const inner = rows.length > 0 ? stringWidth(rows[0]) : 0;
+	const wrapB = opts.borderStyle ?? identity;
+	const wrapT = opts.titleStyle ?? identity;
+	const out = [];
+	out.push(topRow({
+		align: titleAlign ?? "left",
+		chars,
+		inner,
+		title,
+		wrapB,
+		wrapT
+	}));
+	const v = wrapB(chars.v);
+	for (const row of rows) out.push(v + row + v);
+	out.push(wrapB(chars.bl + chars.h.repeat(inner) + chars.br));
+	return out;
+}
+function topRow({ align, chars, inner, title, wrapB, wrapT }) {
+	if (title === void 0 || title === "") return wrapB(chars.tl + chars.h.repeat(inner) + chars.tr);
+	const budget = inner - 4;
+	if (budget <= 0) return wrapB(chars.tl + chars.h.repeat(inner) + chars.tr);
+	const shown = truncate(title, budget);
+	const { leading, trailing } = distributeH(inner - 2 - stringWidth(shown), align);
+	const prefix = wrapB(`${chars.tl}${chars.h.repeat(leading)}`);
+	const titleSeg = wrapT(` ${shown} `);
+	const suffix = wrapB(`${chars.h.repeat(trailing)}${chars.tr}`);
+	return prefix + titleSeg + suffix;
+}
+function distributeH(totalH, align) {
+	if (align === "left") return {
+		leading: 1,
+		trailing: totalH - 1
+	};
+	if (align === "right") return {
+		leading: totalH - 1,
+		trailing: 1
+	};
+	const leading = Math.floor(totalH / 2);
+	return {
+		leading,
+		trailing: totalH - leading
+	};
+}
+function truncate(s, width) {
+	if (stringWidth(s) <= width) return s;
+	if (width <= 1) return "…".repeat(width);
+	return `${sliceAnsi(s, 0, width - 1)}…`;
+}
+//#endregion
+//#region src/widgets/box.ts
+var Box = class extends Node {
+	async _render(ctx) {
+		const style = this.state;
+		const [padT, padR, padB, padL] = resolvePadding(style.padding);
+		const bchars = resolveBorder(style.border);
+		const hasBorder = bchars !== void 0;
+		const chrome = padL + padR + (hasBorder ? 2 : 0);
+		let outer;
+		let contentRows;
+		let inner;
+		if (style.width === "fit") {
+			const upper = Math.max(0, ctx.width - chrome);
+			const tentative = await this.#layoutChildren(upper, ctx);
+			const natural = tentative.reduce((m, r) => Math.max(m, stringWidth(r)), 0);
+			outer = clamp(Math.min(ctx.width, natural + chrome), {
+				available: ctx.width,
+				max: style.maxWidth,
+				min: style.minWidth
+			});
+			inner = Math.max(0, outer - chrome);
+			contentRows = tentative;
+		} else {
+			outer = clamp(resolveSize(style.width ?? "fill", ctx.width) ?? ctx.width, {
+				available: ctx.width,
+				max: style.maxWidth,
+				min: style.minWidth
+			});
+			inner = Math.max(0, outer - chrome);
+			contentRows = await this.#layoutChildren(inner, ctx);
+		}
+		const paddedWidth = Math.max(0, outer - (hasBorder ? 2 : 0));
+		contentRows = contentRows.map((row) => padRow(row, inner));
+		if (padL > 0 || padR > 0) {
+			const lp = " ".repeat(padL);
+			const rp = " ".repeat(padR);
+			contentRows = contentRows.map((row) => lp + row + rp);
+		}
+		const blank = " ".repeat(paddedWidth);
+		const top = Array.from({ length: padT }, () => blank);
+		const bot = Array.from({ length: padB }, () => blank);
+		let rows = [
+			...top,
+			...contentRows,
+			...bot
+		];
+		if (style.height !== void 0) {
+			const innerH = Math.max(0, style.height - (hasBorder ? 2 : 0));
+			if (rows.length > innerH) rows = style.verticalAlign === "bottom" ? rows.slice(-innerH) : rows.slice(0, innerH);
+			else if (rows.length < innerH) {
+				const filler = Array.from({ length: innerH - rows.length }, () => blank);
+				rows = style.verticalAlign === "bottom" ? [...filler, ...rows] : [...rows, ...filler];
+			}
+		}
+		if (bchars) rows = drawBorder(rows, bchars, {
+			borderStyle: ctx.style.add(style.borderStyle ?? "border"),
+			title: await textContent(style.borderTitle, ctx),
+			titleAlign: style.borderTitleAlign,
+			titleStyle: ctx.style.add(style.borderTitleStyle ?? "borderTitle")
+		});
+		const wrap = ctx.style.add(style);
+		return rows.map((row) => wrap(row));
+	}
+	/**
+	* Intrinsic content width derived from children (or the explicit
+	* `width` when fixed). Lets parent flex containers size this Box
+	* without falling back to a measure-render — important for
+	* side-effecting children like `Image` whose first render allocates
+	* a KGP placement: rendering twice would emit two placements and the
+	* second render's `transmitOnce` returns no bytes, so the bytes from
+	* the discarded measure pass would be lost.
+	*
+	* Row direction → bases sum (plus gaps). Column direction → bases
+	* max. Both add chrome (padding + border) at the end.
+	*
+	* Children without `layout()` contribute 0 — the row allocator's
+	* render-measure fallback still kicks in for them at allocation
+	* time, but their absence here just means this Box reports a
+	* smaller intrinsic. That's the safe direction: under-report and
+	* let shrink/grow handle slack, never over-report.
+	*/
+	async layout(ctx) {
+		const s = this.state;
+		const [, padR, , padL] = resolvePadding(s.padding);
+		const chrome = padL + padR + (resolveBorder(s.border) ? 2 : 0);
+		if (isFixedWidth(s.width)) {
+			const w = resolveSize(s.width, ctx.width) ?? 0;
+			return {
+				minWidth: w,
+				width: w
+			};
+		}
+		const kids = layoutNodes(this.children);
+		if (kids.length === 0) return {
+			minWidth: chrome,
+			width: chrome
+		};
+		const isRow = (s.flexDirection ?? "column") === "row";
+		const totalGap = isRow ? (s.gap ?? 0) * Math.max(0, kids.length - 1) : 0;
+		let widthAcc = 0;
+		let minAcc = 0;
+		for (const k of kids) {
+			const l = await k.getLayout(ctx) ?? {
+				minWidth: 0,
+				width: 0
+			};
+			if (isRow) {
+				widthAcc += l.width;
+				minAcc += l.minWidth;
+			} else {
+				widthAcc = Math.max(widthAcc, l.width);
+				minAcc = Math.max(minAcc, l.minWidth);
+			}
+		}
+		return {
+			minWidth: minAcc + totalGap + chrome,
+			width: widthAcc + totalGap + chrome
+		};
+	}
+	async #layoutChildren(innerWidth, ctx) {
+		const children = layoutNodes(this.children);
+		if (children.length === 0) return [];
+		const gap = this.state.gap ?? 0;
+		return (this.state.flexDirection ?? "column") === "row" ? this.#layoutRow(children, innerWidth, ctx, gap) : this.#layoutColumn(children, innerWidth, ctx, gap);
+	}
+	/**
+	* Row direction — main axis is horizontal. CSS-style flex:
+	* each child sizes to its intrinsic content width unless it claims
+	* slack via `flexGrow > 0` or `width: "fill"`. Slack distributes by
+	* grow weights; deficit distributes by `basis * flexShrink` clamped
+	* at each child's `min-content` floor.
+	*
+	* Sizing strategy per child:
+	*   1. `node.layout(ctx)` — sync, content-derived. If implemented,
+	*      use directly; no render needed for measurement.
+	*   2. Otherwise fall back to render-at-innerWidth and measure the
+	*      widest emitted row. Cached; the paint pass reuses the result
+	*      whenever the allocated width matches the measurement width.
+	*
+	* In `fit` mode the parent has no slack to give, so the allocator's
+	* available is capped at the natural sum.
+	*/
+	async #layoutRow(children, innerWidth, ctx, gap) {
+		const intrinsics = await Promise.all(children.map((c) => c.getLayout(ctx)));
+		const measureWidths = children.map((c, i) => {
+			if (intrinsics[i] !== void 0) return -1;
+			if (isFixedWidth(c.state.width)) return resolveSize(c.state.width, innerWidth) ?? innerWidth;
+			return innerWidth;
+		});
+		const measureRows = await Promise.all(children.map((c, i) => {
+			if (measureWidths[i] === -1) return Promise.resolve(void 0);
+			return c.render({
+				...ctx,
+				width: measureWidths[i]
+			});
+		}));
+		const naturals = children.map((c, i) => {
+			if (isFixedWidth(c.state.width)) return resolveSize(c.state.width, innerWidth) ?? 0;
+			const intr = intrinsics[i];
+			if (intr) return intr.width;
+			return (measureRows[i] ?? []).reduce((m, r) => Math.max(m, stringWidth(r)), 0);
+		});
+		const widths = allocateRow(children.map((c, i) => {
+			const s = c.state;
+			return {
+				flexGrow: s.flexGrow,
+				flexShrink: s.flexShrink,
+				intrinsicMin: intrinsics[i]?.minWidth,
+				maxWidth: s.maxWidth,
+				minWidth: s.minWidth,
+				natural: naturals[i],
+				width: s.width
+			};
+		}), {
+			contentWidth: this.state.width === "fit" ? naturals.reduce((a, b) => a + b, 0) + gap * Math.max(0, children.length - 1) : innerWidth,
+			gap
+		});
+		return zipRow((await Promise.all(children.map((c, i) => {
+			const cached = measureRows[i];
+			if (cached !== void 0 && widths[i] === measureWidths[i]) return Promise.resolve(cached);
+			return c.render({
+				...ctx,
+				width: widths[i]
+			});
+		}))).map((rows, i) => rows.map((row) => padRow(row, widths[i]))), {
+			gap,
+			widths
+		});
+	}
+	/**
+	* Column direction — main axis is vertical, cross axis horizontal.
+	* Per CSS `align-items: stretch` (default), children with no
+	* explicit `width` fill the cross axis. A child with a fixed `width`
+	* (number / `Pct`) takes that width as its cross-axis size, with the
+	* leftover padded as right slack (default `flex-start`). `min`/`max`
+	* clamp the resolved width.
+	*
+	* In fit-mode (`width: "fit"`), the cross-axis target shrinks to the
+	* widest child row instead of stretching to `innerWidth` — symmetric
+	* to how row-direction caps allocator-available at the natural sum.
+	*/
+	async #layoutColumn(children, innerWidth, ctx, gap) {
+		const widths = children.map((c) => {
+			const s = c.state;
+			return clamp((isFixedWidth(s.width) ? resolveSize(s.width, innerWidth) : void 0) ?? innerWidth, {
+				available: innerWidth,
+				max: s.maxWidth,
+				min: s.minWidth
+			});
+		});
+		const childRows = await Promise.all(children.map((c, i) => c.render({
+			...ctx,
+			width: widths[i]
+		})));
+		const target = this.state.width === "fit" ? childRows.reduce((m, rows) => rows.reduce((mm, r) => Math.max(mm, stringWidth(r)), m), 0) : innerWidth;
+		return stackColumn(childRows.map((rows) => rows.map((row) => padRow(row, target))), {
+			gap,
+			width: target
+		});
+	}
+};
+/**
+* Factory for `Box`. The style object is required (use `{}` if you don't
+* need any styling) — the previous style-less overload caused TS to fail
+* to discriminate between a Node child and an inferred-empty-state node
+* like `WidgetNode`. Pass `box({}, child1, child2)` for un-styled boxes.
+*
+* Falsy children (`false`, `null`, `undefined`) are filtered out, enabling
+* conditional JSX-like composition: `box({}, cond && child)`.
+*/
+function box(style, ...children) {
+	const b = new Box(style);
+	for (const c of children) if (c) b.add(c);
+	return b;
+}
+/**
+* Flatten fragment nodes (those that implement the `layoutChildren`
+* protocol — `show`, `errorBoundary`, `suspense`) into their currently
+* active leaves. Recursive: a fragment whose `layoutChildren()`
+* itself contains fragments unfolds completely.
+*
+* The fragment Node still lives in the tree (mounted, propagating
+* invalidates) — layout just sees through it so its children share
+* the parent box's flex distribution, gap, and cross-axis sizing
+* instead of collapsing into a single slot.
+*/
+function layoutNodes(children) {
+	return children.flatMap((c) => c.layoutNodes).filter((c) => unwrap(c.state.visible) ?? true);
+}
+function resolvePadding(p) {
+	if (p === void 0) return [
+		0,
+		0,
+		0,
+		0
+	];
+	if (typeof p === "number") return [
+		p,
+		p,
+		p,
+		p
+	];
+	if (p.length === 2) return [
+		p[0],
+		p[1],
+		p[0],
+		p[1]
+	];
+	return [
+		p[0],
+		p[1],
+		p[2],
+		p[3]
+	];
+}
+//#endregion
+export { box as n, Box as t };
+
+//# sourceMappingURL=box-DyaByEiG.mjs.map

package/dist/box-DyaByEiG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"box-DyaByEiG.mjs","names":["#layoutChildren","#layoutRow","#layoutColumn"],"sources":["../src/layout/border.ts","../src/widgets/box.ts"],"sourcesContent":["import type { StyleBuilder } from \"../style/builder.ts\"\n\nimport { sliceAnsi, stringWidth } from \"@zaly/shared/ansi\"\n\n/**\n * Border-character glyphs for drawing a box outline. Any single-cell string\n * is allowed (including multi-byte glyphs like rounded corners).\n */\nexport interface BorderChars {\n  h: string\n  v: string\n  tl: string\n  tr: string\n  bl: string\n  br: string\n}\n\nexport type BorderSpec = boolean | \"single\" | \"double\" | \"rounded\" | BorderChars\n\n/** @internal */\nexport const borders = {\n  double: { bl: \"╚\", br: \"╝\", h: \"═\", tl: \"╔\", tr: \"╗\", v: \"║\" },\n  rounded: { bl: \"╰\", br: \"╯\", h: \"─\", tl: \"╭\", tr: \"╮\", v: \"│\" },\n  single: { bl: \"└\", br: \"┘\", h: \"─\", tl: \"┌\", tr: \"┐\", v: \"│\" },\n} as const satisfies Record<string, BorderChars>\n\n/** Resolve the `border` style value to a concrete BorderChars, or undefined.\n *\n * @internal*/\nexport function resolveBorder(spec: BorderSpec | undefined): BorderChars | undefined {\n  if (spec === undefined || spec === false) return undefined\n  if (spec === true) return borders.single\n  if (typeof spec === \"string\") return borders[spec]\n  return spec\n}\n\nexport type TitleAlign = \"left\" | \"center\" | \"right\"\n\nexport interface DrawBorderOpts {\n  /**\n   * Optional title embedded in the top border, with a single-cell space on\n   * each side. Ellipsis-truncated when it overflows the budget.\n   */\n  title?: string\n  /** Placement of `title` along the top border. Defaults to `\"left\"`. */\n  titleAlign?: TitleAlign\n  /**\n   * Styled wrapper applied to the border glyphs (corners, horizontal,\n   * vertical). Use `ctx.style.add(slotOrStyle)` at the call site so the\n   * theme is resolved once per render.\n   */\n  borderStyle?: StyleBuilder\n  /** Styled wrapper applied to the title text (including the padding spaces). */\n  titleStyle?: StyleBuilder\n}\n\n/** Pass-through wrapper used when no style is supplied. */\nconst identity = (s: string): string => s\n\n/**\n * Wrap pre-rendered inner rows with a border, adding top/bottom border rows\n * and left/right border chars to each inner row. Inner rows must be padded\n * to a uniform width; the output rows are `innerWidth + 2` wide.\n *\n * Border glyphs and the optional title can be styled independently via\n * `borderStyle` / `titleStyle` — each is a pre-bound `StyleBuilder`, so\n * this helper stays purely about geometry and never touches SGR itself.\n *\n * @internal\n */\nexport function drawBorder(\n  rows: readonly string[],\n  chars: BorderChars,\n  opts: DrawBorderOpts = {}\n): string[] {\n  const { title, titleAlign } = opts\n  const inner = rows.length > 0 ? stringWidth(rows[0]) : 0\n  const wrapB = opts.borderStyle ?? identity\n  const wrapT = opts.titleStyle ?? identity\n\n  const out: string[] = []\n  out.push(topRow({ align: titleAlign ?? \"left\", chars, inner, title, wrapB, wrapT }))\n  const v = wrapB(chars.v)\n  for (const row of rows) out.push(v + row + v)\n  out.push(wrapB(chars.bl + chars.h.repeat(inner) + chars.br))\n  return out\n}\n\ninterface TopRowArgs {\n  align: TitleAlign\n  chars: BorderChars\n  inner: number\n  title: string | undefined\n  wrapB: (s: string) => string\n  wrapT: (s: string) => string\n}\n\nfunction topRow({ align, chars, inner, title, wrapB, wrapT }: TopRowArgs): string {\n  if (title === undefined || title === \"\") {\n    return wrapB(chars.tl + chars.h.repeat(inner) + chars.tr)\n  }\n  // Chrome: h + space + title + space + h (4 cells of chrome around the title)\n  const budget = inner - 4\n  if (budget <= 0) return wrapB(chars.tl + chars.h.repeat(inner) + chars.tr)\n  const shown = truncate(title, budget)\n  const totalH = inner - 2 - stringWidth(shown)\n  const { leading, trailing } = distributeH(totalH, align)\n  const prefix = wrapB(`${chars.tl}${chars.h.repeat(leading)}`)\n  const titleSeg = wrapT(` ${shown} `)\n  const suffix = wrapB(`${chars.h.repeat(trailing)}${chars.tr}`)\n  return prefix + titleSeg + suffix\n}\n\nfunction distributeH(totalH: number, align: TitleAlign): { leading: number; trailing: number } {\n  if (align === \"left\") return { leading: 1, trailing: totalH - 1 }\n  if (align === \"right\") return { leading: totalH - 1, trailing: 1 }\n  // center: leading rounds down so odd slack biases the title slightly left.\n  const leading = Math.floor(totalH / 2)\n  return { leading, trailing: totalH - leading }\n}\n\nfunction truncate(s: string, width: number): string {\n  if (stringWidth(s) <= width) return s\n  if (width <= 1) return \"…\".repeat(width)\n  return `${sliceAnsi(s, 0, width - 1)}…`\n}\n","import type { RenderCtx } from \"../core/ctx.ts\"\nimport type { State } from \"../core/state.ts\"\nimport type { BorderSpec, TitleAlign } from \"../layout/border.ts\"\nimport type { RowItem } from \"../layout/flex.ts\"\nimport type { Style } from \"../style/types.ts\"\nimport type { TextContent } from \"./text.ts\"\n\nimport { stringWidth } from \"@zaly/shared/ansi\"\nimport { Node } from \"../core/node.ts\"\nimport { unwrap } from \"../core/reactive.ts\"\nimport { drawBorder, resolveBorder } from \"../layout/border.ts\"\nimport { allocateRow, isFixedWidth, padRow, stackColumn, zipRow } from \"../layout/flex.ts\"\nimport { clamp, resolveSize } from \"../layout/size.ts\"\nimport { textContent } from \"./text.ts\"\n\nexport type Padding =\n  | number\n  | readonly [v: number, h: number]\n  | readonly [t: number, r: number, b: number, l: number]\n\nexport interface BoxStyle extends Style {\n  flexDirection?: \"row\" | \"column\"\n  gap?: number\n  /** Fixed outer height in rows. When unset, the box's height emerges\n   *  naturally from its content + padding + border. When set, the\n   *  content area is truncated or padded with blank rows to land at\n   *  exactly this many rows of *outer* height. Pair with\n   *  `verticalAlign` to control which edge is anchored. */\n  height?: number\n  /** Anchor for the content when `height` truncates or extends.\n   *  `\"top\"` (default) keeps the top edge: extra rows added at the\n   *  bottom, overflow truncated from the bottom. `\"bottom\"` keeps the\n   *  bottom edge: extra rows prepended, overflow truncated from the\n   *  top. Other CSS-like values (`middle`) are not implemented. */\n  verticalAlign?: \"top\" | \"bottom\"\n  padding?: Padding\n  border?: BorderSpec\n  borderTitle?: TextContent\n  /** Placement of `borderTitle` along the top border. Defaults to `\"left\"`. */\n  borderTitleAlign?: TitleAlign\n  /**\n   * Style applied to the border glyphs. Either a theme slot name (resolved\n   * via the active theme) or an inline `Style`. Defaults to the `\"border\"`\n   * theme slot when a border is drawn.\n   */\n  borderStyle?: string | Style\n  /**\n   * Style applied to the border title. Defaults to the `\"borderTitle\"` theme\n   * slot when a title is set.\n   */\n  borderTitleStyle?: string | Style\n}\n\nexport class Box<T extends object = {}> extends Node<BoxStyle & T> {\n  protected async _render(ctx: RenderCtx): Promise<string[]> {\n    const style = this.state\n\n    const [padT, padR, padB, padL] = resolvePadding(style.padding)\n    const bchars = resolveBorder(style.border)\n    const hasBorder = bchars !== undefined\n    const chrome = padL + padR + (hasBorder ? 2 : 0)\n\n    let outer: number\n    let contentRows: string[]\n    let inner: number\n\n    if (style.width === \"fit\") {\n      // `fit`: render children at the parent's max inner width, measure\n      // the natural max-row width, then clamp the box to that. Two-pass\n      // — the first pass uses the upper bound as a measuring window,\n      // the second re-pads each row to the chosen inner width.\n      const upper = Math.max(0, ctx.width - chrome)\n      const tentative = await this.#layoutChildren(upper, ctx)\n      const natural = tentative.reduce((m, r) => Math.max(m, stringWidth(r)), 0)\n      const fit = Math.min(ctx.width, natural + chrome)\n      outer = clamp(fit, {\n        available: ctx.width,\n        max: style.maxWidth,\n        min: style.minWidth,\n      })\n      inner = Math.max(0, outer - chrome)\n      contentRows = tentative\n    } else {\n      const requested = resolveSize(style.width ?? \"fill\", ctx.width) ?? ctx.width\n      outer = clamp(requested, {\n        available: ctx.width,\n        max: style.maxWidth,\n        min: style.minWidth,\n      })\n      inner = Math.max(0, outer - chrome)\n      contentRows = await this.#layoutChildren(inner, ctx)\n    }\n\n    const paddedWidth = Math.max(0, outer - (hasBorder ? 2 : 0))\n\n    // Ensure each content row is exactly `inner` cells wide (absorbs slack).\n    contentRows = contentRows.map((row) => padRow(row, inner))\n\n    // Horizontal padding.\n    if (padL > 0 || padR > 0) {\n      const lp = \" \".repeat(padL)\n      const rp = \" \".repeat(padR)\n      contentRows = contentRows.map((row) => lp + row + rp)\n    }\n\n    // Vertical padding.\n    const blank = \" \".repeat(paddedWidth)\n    const top = Array.from({ length: padT }, () => blank)\n    const bot = Array.from({ length: padB }, () => blank)\n    let rows = [...top, ...contentRows, ...bot]\n\n    // Fixed-height fit. The `height` field is the outer dimension —\n    // border takes its 2 rows out before we measure against the\n    // content area; padding is already baked into `rows`. `verticalAlign`\n    // decides which end gets clipped (when too tall) or padded (when\n    // too short). Default `\"top\"` matches the natural reading flow.\n    if (style.height !== undefined) {\n      const innerH = Math.max(0, style.height - (hasBorder ? 2 : 0))\n      if (rows.length > innerH) {\n        rows = style.verticalAlign === \"bottom\" ? rows.slice(-innerH) : rows.slice(0, innerH)\n      } else if (rows.length < innerH) {\n        const filler = Array.from({ length: innerH - rows.length }, () => blank)\n        rows = style.verticalAlign === \"bottom\" ? [...filler, ...rows] : [...rows, ...filler]\n      }\n    }\n\n    if (bchars) {\n      rows = drawBorder(rows, bchars, {\n        borderStyle: ctx.style.add(style.borderStyle ?? \"border\"),\n        title: await textContent(style.borderTitle, ctx),\n        titleAlign: style.borderTitleAlign,\n        titleStyle: ctx.style.add(style.borderTitleStyle ?? \"borderTitle\"),\n      })\n    }\n\n    const wrap = ctx.style.add(style)\n    return rows.map((row) => wrap(row))\n  }\n\n  /**\n   * Intrinsic content width derived from children (or the explicit\n   * `width` when fixed). Lets parent flex containers size this Box\n   * without falling back to a measure-render — important for\n   * side-effecting children like `Image` whose first render allocates\n   * a KGP placement: rendering twice would emit two placements and the\n   * second render's `transmitOnce` returns no bytes, so the bytes from\n   * the discarded measure pass would be lost.\n   *\n   * Row direction → bases sum (plus gaps). Column direction → bases\n   * max. Both add chrome (padding + border) at the end.\n   *\n   * Children without `layout()` contribute 0 — the row allocator's\n   * render-measure fallback still kicks in for them at allocation\n   * time, but their absence here just means this Box reports a\n   * smaller intrinsic. That's the safe direction: under-report and\n   * let shrink/grow handle slack, never over-report.\n   */\n  override async layout(ctx: RenderCtx) {\n    const s = this.state\n    const [, padR, , padL] = resolvePadding(s.padding)\n    const chrome = padL + padR + (resolveBorder(s.border) ? 2 : 0)\n\n    // Fixed width wins outright.\n    if (isFixedWidth(s.width)) {\n      const w = resolveSize(s.width, ctx.width) ?? 0\n      return { minWidth: w, width: w }\n    }\n\n    const kids = layoutNodes(this.children)\n    if (kids.length === 0) return { minWidth: chrome, width: chrome }\n\n    const isRow = (s.flexDirection ?? \"column\") === \"row\"\n    const totalGap = isRow ? (s.gap ?? 0) * Math.max(0, kids.length - 1) : 0\n\n    let widthAcc = 0\n    let minAcc = 0\n    for (const k of kids) {\n      // oxlint-disable-next-line no-await-in-loop\n      const l = (await k.getLayout(ctx)) ?? { minWidth: 0, width: 0 }\n      if (isRow) {\n        widthAcc += l.width\n        minAcc += l.minWidth\n      } else {\n        widthAcc = Math.max(widthAcc, l.width)\n        minAcc = Math.max(minAcc, l.minWidth)\n      }\n    }\n\n    return { minWidth: minAcc + totalGap + chrome, width: widthAcc + totalGap + chrome }\n  }\n\n  async #layoutChildren(innerWidth: number, ctx: RenderCtx): Promise<string[]> {\n    const children = layoutNodes(this.children)\n    if (children.length === 0) return []\n    const gap = this.state.gap ?? 0\n    return (this.state.flexDirection ?? \"column\") === \"row\"\n      ? this.#layoutRow(children, innerWidth, ctx, gap)\n      : this.#layoutColumn(children, innerWidth, ctx, gap)\n  }\n\n  /**\n   * Row direction — main axis is horizontal. CSS-style flex:\n   * each child sizes to its intrinsic content width unless it claims\n   * slack via `flexGrow > 0` or `width: \"fill\"`. Slack distributes by\n   * grow weights; deficit distributes by `basis * flexShrink` clamped\n   * at each child's `min-content` floor.\n   *\n   * Sizing strategy per child:\n   *   1. `node.layout(ctx)` — sync, content-derived. If implemented,\n   *      use directly; no render needed for measurement.\n   *   2. Otherwise fall back to render-at-innerWidth and measure the\n   *      widest emitted row. Cached; the paint pass reuses the result\n   *      whenever the allocated width matches the measurement width.\n   *\n   * In `fit` mode the parent has no slack to give, so the allocator's\n   * available is capped at the natural sum.\n   */\n  async #layoutRow(\n    children: readonly Node[],\n    innerWidth: number,\n    ctx: RenderCtx,\n    gap: number\n  ): Promise<string[]> {\n    // Phase 1: figure out each child's intrinsic size.\n    // - `layout()` short-circuits — sync, no render.\n    // - Fallback: render at the upper bound (innerWidth or fixed spec)\n    //   and measure rows.\n    const intrinsics = await Promise.all(children.map((c) => c.getLayout(ctx)))\n    // For children with intrinsic sizing, skip the measure render\n    // entirely. Others fall back to render-at-upper-bound (their fixed\n    // width, or innerWidth if fluid).\n    const measureWidths = children.map((c, i) => {\n      if (intrinsics[i] !== undefined) return -1\n      if (isFixedWidth(c.state.width)) {\n        return resolveSize(c.state.width, innerWidth) ?? innerWidth\n      }\n      return innerWidth\n    })\n    const measureRows = await Promise.all(\n      children.map((c, i): Promise<string[] | undefined> => {\n        if (measureWidths[i] === -1) return Promise.resolve(undefined)\n        return c.render({ ...ctx, width: measureWidths[i] })\n      })\n    )\n    const naturals = children.map((c, i) => {\n      // A fixed `state.width` is what the allocator will actually\n      // assign this child — use it directly so the fit-mode\n      // `allocAvailable` sum below matches what we'll consume. Falling\n      // back to intrinsic when there's no override under-reports a\n      // child like `text(\"x\", { width: 2 })` and shrinks every sibling\n      // by the missing cells.\n      if (isFixedWidth(c.state.width)) {\n        return resolveSize(c.state.width, innerWidth) ?? 0\n      }\n      const intr = intrinsics[i]\n      if (intr) return intr.width\n      return (measureRows[i] ?? []).reduce((m, r) => Math.max(m, stringWidth(r)), 0)\n    })\n    const items: RowItem[] = children.map((c, i) => {\n      const s = c.state\n      return {\n        flexGrow: s.flexGrow,\n        flexShrink: s.flexShrink,\n        intrinsicMin: intrinsics[i]?.minWidth,\n        maxWidth: s.maxWidth,\n        minWidth: s.minWidth,\n        natural: naturals[i],\n        width: s.width,\n      }\n    })\n    const allocAvailable =\n      this.state.width === \"fit\"\n        ? naturals.reduce((a, b) => a + b, 0) + gap * Math.max(0, children.length - 1)\n        : innerWidth\n    const widths = allocateRow(items, { contentWidth: allocAvailable, gap })\n    // Phase 2: paint at allocated widths. Reuse the measure-render when\n    // the allocation matches; otherwise render fresh (cached).\n    const childRows = await Promise.all(\n      children.map((c, i): Promise<string[]> => {\n        const cached = measureRows[i]\n        if (cached !== undefined && widths[i] === measureWidths[i]) {\n          return Promise.resolve(cached)\n        }\n        return c.render({ ...ctx, width: widths[i] })\n      })\n    )\n    // `zipRow` expects rows to be exactly `widths[i]` wide. Children\n    // that emit natural-width rows (text default, code default) get\n    // padded here so the contract holds; over-wide rows get clipped.\n    const padded = childRows.map((rows, i) => rows.map((row) => padRow(row, widths[i])))\n    return zipRow(padded, { gap, widths })\n  }\n\n  /**\n   * Column direction — main axis is vertical, cross axis horizontal.\n   * Per CSS `align-items: stretch` (default), children with no\n   * explicit `width` fill the cross axis. A child with a fixed `width`\n   * (number / `Pct`) takes that width as its cross-axis size, with the\n   * leftover padded as right slack (default `flex-start`). `min`/`max`\n   * clamp the resolved width.\n   *\n   * In fit-mode (`width: \"fit\"`), the cross-axis target shrinks to the\n   * widest child row instead of stretching to `innerWidth` — symmetric\n   * to how row-direction caps allocator-available at the natural sum.\n   */\n  async #layoutColumn(\n    children: readonly Node[],\n    innerWidth: number,\n    ctx: RenderCtx,\n    gap: number\n  ): Promise<string[]> {\n    const widths = children.map((c) => {\n      const s = c.state\n      const fixed = isFixedWidth(s.width) ? resolveSize(s.width, innerWidth) : undefined\n      const w = fixed ?? innerWidth\n      return clamp(w, { available: innerWidth, max: s.maxWidth, min: s.minWidth })\n    })\n    const childRows = await Promise.all(\n      children.map((c, i) => c.render({ ...ctx, width: widths[i] }))\n    )\n    const target =\n      this.state.width === \"fit\"\n        ? childRows.reduce((m, rows) => rows.reduce((mm, r) => Math.max(mm, stringWidth(r)), m), 0)\n        : innerWidth\n    // Pad each child's rows to the cross-axis target. For full-stretch\n    // children this absorbs natural-row slack; for fixed-width\n    // children it adds right-side slack (default `flex-start`\n    // alignment). `stackColumn`'s contract requires uniform width.\n    const padded = childRows.map((rows) => rows.map((row) => padRow(row, target)))\n    return stackColumn(padded, { gap, width: target })\n  }\n}\n\ntype Child = Node | false | null | undefined\n\n/**\n * Factory for `Box`. The style object is required (use `{}` if you don't\n * need any styling) — the previous style-less overload caused TS to fail\n * to discriminate between a Node child and an inferred-empty-state node\n * like `WidgetNode`. Pass `box({}, child1, child2)` for un-styled boxes.\n *\n * Falsy children (`false`, `null`, `undefined`) are filtered out, enabling\n * conditional JSX-like composition: `box({}, cond && child)`.\n */\nexport function box(style: State<BoxStyle>, ...children: Child[]): Box {\n  const b = new Box(style)\n  for (const c of children) if (c) b.add(c)\n  return b\n}\n\n/**\n * Flatten fragment nodes (those that implement the `layoutChildren`\n * protocol — `show`, `errorBoundary`, `suspense`) into their currently\n * active leaves. Recursive: a fragment whose `layoutChildren()`\n * itself contains fragments unfolds completely.\n *\n * The fragment Node still lives in the tree (mounted, propagating\n * invalidates) — layout just sees through it so its children share\n * the parent box's flex distribution, gap, and cross-axis sizing\n * instead of collapsing into a single slot.\n */\nfunction layoutNodes(children: readonly Node[]): readonly Node[] {\n  return children.flatMap((c) => c.layoutNodes).filter((c) => unwrap(c.state.visible) ?? true)\n}\n\nfunction resolvePadding(p: Padding | undefined): [t: number, r: number, b: number, l: number] {\n  if (p === undefined) return [0, 0, 0, 0]\n  if (typeof p === \"number\") return [p, p, p, p]\n  if (p.length === 2) return [p[0], p[1], p[0], p[1]]\n  return [p[0], p[1], p[2], p[3]]\n}\n"],"mappings":"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"}