@flyingrobots/bijou 4.4.1 → 7.0.0

package/dist/core/components/table.js

@@ -1,18 +1,42 @@
-import { graphemeWidth } from '../text/grapheme.js';
-import { clipToWidth } from '../text/clip.js';
+import { RESET_SGR } from '../ansi.js';
+import { ANSI_OSC8_RE, ANSI_SGR_RE, graphemeClusterWidth, segmentGraphemes, stripAnsi, } from '../text/grapheme.js';
 import { wrapToWidth } from '../text/wrap.js';
 import { resolveCtx } from '../resolve-ctx.js';
 import { renderByMode } from '../mode-render.js';
 import { makeBgFill } from '../bg-fill.js';
+import { sanitizeNonNegativeInt, sanitizeOptionalNonNegativeInt, sanitizeOptionalPositiveInt, sanitizePositiveInt, } from '../numeric.js';
 import { resolveOverflowBehavior } from './overflow.js';
 /**
- * Calculate the visible (non-ANSI) character length of a string.
+ * Structural width added by the interactive table frame for a given column count.
+ *
+ * Each column contributes two padding spaces and one vertical divider, with one
+ * extra border character for the outer edge.
+ */
+export function interactiveTableBorderOverhead(columnCount) {
+    return Math.max(0, columnCount) * 3 + 1;
+}
+/**
+ * Total rendered width of an interactive table for the supplied column widths.
+ */
+export function measureInteractiveTableWidth(columnWidths) {
+    return columnWidths.reduce((total, width) => total + width, 0)
+        + interactiveTableBorderOverhead(columnWidths.length);
+}
+function isTableOptions(value) {
+    return !Array.isArray(value);
+}
+/**
+ * Calculate the visible (non-ANSI) display width of a string.
  *
  * @param str - Input string potentially containing ANSI codes.
- * @returns The number of visible characters.
+ * @returns The number of visible terminal columns.
  */
 function visibleLength(str) {
-    return graphemeWidth(str);
+    let width = 0;
+    for (const grapheme of segmentGraphemes(stripAnsi(str))) {
+        width += tableGraphemeWidth(grapheme);
+    }
+    return width;
 }
 /**
  * Right-pad a string to a target width, accounting for ANSI escape sequences.
@@ -25,96 +49,646 @@ function padRight(str, width) {
     const visible = visibleLength(str);
     return visible >= width ? str : str + ' '.repeat(width - visible);
 }
+function padLeft(str, width) {
+    const visible = visibleLength(str);
+    return visible >= width ? str : ' '.repeat(width - visible) + str;
+}
+function padCenter(str, width) {
+    const visible = visibleLength(str);
+    if (visible >= width)
+        return str;
+    const remaining = width - visible;
+    const left = Math.floor(remaining / 2);
+    return ' '.repeat(left) + str + ' '.repeat(remaining - left);
+}
+function alignCell(str, width, align) {
+    if (align === 'right')
+        return padLeft(str, width);
+    if (align === 'center')
+        return padCenter(str, width);
+    return padRight(str, width);
+}
 function normalizeColumnWidth(width) {
-    if (width == null)
-        return undefined;
-    if (!Number.isFinite(width))
-        return 0;
-    return Math.max(0, Math.floor(width));
+    return sanitizeOptionalNonNegativeInt(width);
+}
+function normalizePositiveWeight(weight) {
+    if (weight == null || !Number.isFinite(weight))
+        return 1;
+    return Math.max(0, Math.floor(weight));
+}
+function maxVisibleLineWidth(value) {
+    const lines = String(value ?? '').split('\n');
+    return lines.reduce((max, line) => Math.max(max, visibleLength(line)), 0);
+}
+function normalizeRows(rows) {
+    return (rows ?? []).map(row => (row ?? []).map(cell => String(cell ?? '')));
+}
+function resolveColumns(suppliedColumns, rows, variant) {
+    const columns = suppliedColumns ?? [];
+    if (columns.length > 0)
+        return [...columns];
+    if (variant === 'definition') {
+        return [
+            { header: 'Field', minWidth: 5 },
+            { header: 'Value', minWidth: 5, weight: 3 },
+        ];
+    }
+    const inferredCount = rows.reduce((max, row) => Math.max(max, row.length), 0);
+    return Array.from({ length: inferredCount }, () => ({ header: '' }));
+}
+function normalizeTable(options) {
+    const rows = normalizeRows(options.rows);
+    const variant = options.variant ?? 'box';
+    const columns = resolveColumns(options.columns, rows, variant);
+    return {
+        columns,
+        rows,
+        showHeader: variant === 'definition' || columns.some(column => (column.header ?? '').length > 0),
+    };
+}
+function structuralOverhead(variant, columnCount, columnGap) {
+    if (columnCount <= 0)
+        return variant === 'box' || variant === 'ascii-grid' ? 2 : 0;
+    if (variant === 'box' || variant === 'ascii-grid') {
+        return interactiveTableBorderOverhead(columnCount);
+    }
+    if (variant === 'markdown') {
+        return columnCount * 3 + 1;
+    }
+    return Math.max(0, columnCount - 1) * columnGap;
+}
+function resolveTargetWidth(options, ctx, layout) {
+    const explicitWidth = sanitizeOptionalPositiveInt(options.width);
+    if (explicitWidth !== undefined)
+        return explicitWidth;
+    const explicitMaxWidth = sanitizeOptionalPositiveInt(options.maxWidth);
+    if (layout === 'intrinsic')
+        return explicitMaxWidth;
+    const runtimeWidth = sanitizePositiveInt(ctx.runtime.columns, 80);
+    return explicitMaxWidth === undefined ? runtimeWidth : Math.min(runtimeWidth, explicitMaxWidth);
 }
-function formatCellLines(value, width, overflow, fixedWidth) {
+function columnPreferredWidth(column, rows, columnIndex) {
+    const fixedWidth = normalizeColumnWidth(column.width);
+    if (fixedWidth !== undefined)
+        return fixedWidth;
+    let preferred = Math.max(1, maxVisibleLineWidth(column.header ?? ''));
+    for (const row of rows) {
+        preferred = Math.max(preferred, maxVisibleLineWidth(row[columnIndex] ?? ''));
+    }
+    const maxWidth = sanitizeOptionalNonNegativeInt(column.maxWidth);
+    if (maxWidth !== undefined)
+        preferred = Math.min(preferred, maxWidth);
+    const minWidth = sanitizeOptionalNonNegativeInt(column.minWidth);
+    if (minWidth !== undefined)
+        preferred = Math.max(preferred, Math.min(minWidth, maxWidth ?? minWidth));
+    return preferred;
+}
+function columnMinWidth(column, preferredWidth) {
+    const fixedWidth = normalizeColumnWidth(column.width);
+    if (fixedWidth !== undefined)
+        return fixedWidth;
+    const maxWidth = sanitizeOptionalNonNegativeInt(column.maxWidth);
+    const rawMinWidth = sanitizeOptionalNonNegativeInt(column.minWidth) ?? Math.min(1, preferredWidth);
+    const constrainedMin = Math.min(rawMinWidth, maxWidth ?? rawMinWidth);
+    return Math.min(preferredWidth, constrainedMin);
+}
+function fitColumnWidths(columns, rows, variant, layout, targetWidth, columnGap) {
+    const preferred = columns.map((column, index) => columnPreferredWidth(column, rows, index));
+    if (layout === 'intrinsic' && targetWidth === undefined)
+        return preferred;
+    const contentTarget = targetWidth === undefined
+        ? undefined
+        : Math.max(0, targetWidth - structuralOverhead(variant, columns.length, columnGap));
+    if (contentTarget === undefined)
+        return preferred;
+    const preferredTotal = preferred.reduce((sum, width) => sum + width, 0);
+    if (preferredTotal <= contentTarget)
+        return preferred;
+    const minimum = columns.map((column, index) => columnMinWidth(column, preferred[index]));
+    const minimumTotal = minimum.reduce((sum, width) => sum + width, 0);
+    if (minimumTotal >= contentTarget)
+        return minimum;
+    const widths = [...minimum];
+    const remainingCapacity = preferred.map((width, index) => Math.max(0, width - minimum[index]));
+    let remainingBudget = contentTarget - minimumTotal;
+    while (remainingBudget > 0) {
+        const active = remainingCapacity
+            .map((capacity, index) => ({ capacity, index }))
+            .filter(entry => entry.capacity > 0);
+        if (active.length === 0)
+            break;
+        const totalWeight = active.reduce((sum, entry) => {
+            return sum + Math.max(1, normalizePositiveWeight(columns[entry.index]?.weight));
+        }, 0);
+        let used = 0;
+        const remainders = [];
+        for (const entry of active) {
+            const weight = Math.max(1, normalizePositiveWeight(columns[entry.index]?.weight));
+            const exact = (remainingBudget * weight) / totalWeight;
+            const add = Math.min(entry.capacity, Math.floor(exact));
+            if (add > 0) {
+                widths[entry.index] += add;
+                remainingCapacity[entry.index] -= add;
+                used += add;
+            }
+            remainders.push({
+                index: entry.index,
+                remainder: exact - Math.floor(exact),
+                capacity: remainingCapacity[entry.index],
+            });
+        }
+        if (used === 0) {
+            const sortedRemainders = remainders
+                .filter(entry => entry.capacity > 0)
+                .sort((left, right) => {
+                if (right.remainder !== left.remainder)
+                    return right.remainder - left.remainder;
+                return remainingCapacity[right.index] - remainingCapacity[left.index];
+            });
+            const next = sortedRemainders[0];
+            if (!next)
+                break;
+            widths[next.index]++;
+            remainingCapacity[next.index]--;
+            used = 1;
+        }
+        remainingBudget -= used;
+    }
+    return widths;
+}
+function formatCellLines(value, width, overflow, wrapMode) {
     const safeValue = value ?? '';
-    if (!fixedWidth)
-        return safeValue.split('\n');
     if (overflow === 'truncate') {
-        return safeValue.split('\n').map((line) => clipToWidth(line, width));
+        return safeValue.split('\n').map(line => clipCellToWidth(line, width));
     }
-    return safeValue.split('\n').flatMap((line) => wrapToWidth(line, width));
+    if (wrapMode === 'word')
+        return wrapToWidth(safeValue, width);
+    return safeValue.split('\n').flatMap(line => wrapCellToWidth(line, width));
 }
-/**
- * Render a table with unicode box-drawing borders.
- *
- * Output adapts to the current output mode:
- * - `interactive` / `static` — bordered table with styled headers.
- * - `pipe` — tab-separated values (TSV).
- * - `accessible` — key-value pairs per row for screen readers.
- *
- * @param options - Table configuration including columns and row data.
- * @returns The rendered table string.
- */
-export function table(options) {
+const TABLE_EMOJI_PRESENTATION_RE = /\p{Emoji_Presentation}/u;
+function tableGraphemeWidth(grapheme) {
+    if (TABLE_EMOJI_PRESENTATION_RE.test(grapheme))
+        return 2;
+    return graphemeClusterWidth(grapheme);
+}
+function isOsc8Escape(raw) {
+    return raw.startsWith('\x1b]8;;');
+}
+const OSC8_CLOSE = '\x1b]8;;\x1b\\';
+const OSC8_CLOSE_BEL = '\x1b]8;;\x07';
+function isOsc8Close(raw) {
+    return raw === OSC8_CLOSE || raw === OSC8_CLOSE_BEL;
+}
+function isResetEscape(raw) {
+    return raw === RESET_SGR;
+}
+function tokenizeTableText(str) {
+    const regex = new RegExp(`${ANSI_SGR_RE.source}|${ANSI_OSC8_RE.source}`, 'g');
+    const tokens = [];
+    let lastIndex = 0;
+    for (const match of str.matchAll(regex)) {
+        const index = match.index ?? 0;
+        if (index > lastIndex) {
+            const raw = str.slice(lastIndex, index);
+            for (const grapheme of segmentGraphemes(raw)) {
+                tokens.push({
+                    kind: 'grapheme',
+                    raw: grapheme,
+                    width: tableGraphemeWidth(grapheme),
+                });
+            }
+        }
+        tokens.push({ kind: 'ansi', raw: match[0] });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < str.length) {
+        const raw = str.slice(lastIndex);
+        for (const grapheme of segmentGraphemes(raw)) {
+            tokens.push({
+                kind: 'grapheme',
+                raw: grapheme,
+                width: tableGraphemeWidth(grapheme),
+            });
+        }
+    }
+    return tokens;
+}
+function activeTableAnsiPrefix(activeOsc8, activeStyle) {
+    return activeOsc8 + activeStyle;
+}
+function finalizeTableWrappedLine(raw, activeOsc8, activeStyle) {
+    let result = raw;
+    if (activeOsc8.length > 0 && !result.endsWith(OSC8_CLOSE) && !result.endsWith(OSC8_CLOSE_BEL)) {
+        result += OSC8_CLOSE;
+    }
+    if (activeStyle.length > 0 && !result.endsWith(RESET_SGR)) {
+        result += RESET_SGR;
+    }
+    return result;
+}
+function clipCellToWidth(str, maxWidth) {
+    if (maxWidth <= 0)
+        return '';
+    const tokens = tokenizeTableText(str);
+    let visible = 0;
+    let result = '';
+    let hasStyle = false;
+    let activeOsc8 = '';
+    for (const token of tokens) {
+        if (token.kind === 'ansi') {
+            result += token.raw;
+            if (isOsc8Escape(token.raw)) {
+                activeOsc8 = isOsc8Close(token.raw) ? '' : token.raw;
+            }
+            else {
+                hasStyle = !isResetEscape(token.raw);
+            }
+            continue;
+        }
+        if (visible + token.width > maxWidth) {
+            if (activeOsc8.length > 0)
+                result += OSC8_CLOSE;
+            if (hasStyle && !result.endsWith(RESET_SGR))
+                result += RESET_SGR;
+            break;
+        }
+        result += token.raw;
+        visible += token.width;
+    }
+    return activeOsc8.length > 0 || hasStyle
+        ? finalizeTableWrappedLine(result, activeOsc8, hasStyle ? RESET_SGR : '')
+        : result;
+}
+function wrapCellToWidth(str, maxWidth) {
+    if (maxWidth <= 0)
+        return [''];
+    const tokens = tokenizeTableText(str);
+    if (tokens.length === 0)
+        return [''];
+    const lines = [];
+    let current = '';
+    let currentWidth = 0;
+    let activeStyle = '';
+    let activeOsc8 = '';
+    for (const token of tokens) {
+        if (token.kind === 'ansi') {
+            current += token.raw;
+            if (isOsc8Escape(token.raw)) {
+                activeOsc8 = isOsc8Close(token.raw) ? '' : token.raw;
+                continue;
+            }
+            activeStyle = isResetEscape(token.raw) ? '' : activeStyle + token.raw;
+            continue;
+        }
+        if (currentWidth + token.width > maxWidth && currentWidth > 0) {
+            lines.push(finalizeTableWrappedLine(current, activeOsc8, activeStyle));
+            current = activeTableAnsiPrefix(activeOsc8, activeStyle) + token.raw;
+            currentWidth = token.width;
+            continue;
+        }
+        current += token.raw;
+        currentWidth += token.width;
+    }
+    if (current.length > 0) {
+        lines.push(finalizeTableWrappedLine(current, activeOsc8, activeStyle));
+    }
+    return lines.length > 0 ? lines : [''];
+}
+function buildFittedTable(options, ctx, tableData, variant, optionsOverride = {}) {
+    const columns = optionsOverride.columns ?? tableData.columns;
+    const rows = optionsOverride.rows ?? tableData.rows;
+    const layout = optionsOverride.layout ?? options.layout ?? 'auto';
+    const columnGap = sanitizeNonNegativeInt(options.columnGap, 2);
+    const overflow = resolveOverflowBehavior(options.overflow, ctx.resolveBCSS({ type: 'Table', id: options.id, classes: options.class?.split(' ') }));
+    const wrapMode = options.wrap ?? 'word';
+    const widths = fitColumnWidths(columns, rows, variant, layout, resolveTargetWidth(options, ctx, layout), columnGap);
+    const headerToken = options.headerToken ?? ctx.ui('tableHeader');
+    const styleHeaders = optionsOverride.styleHeaders ?? true;
+    const headerLines = columns.map((column, index) => {
+        const header = column.header ?? '';
+        const value = styleHeaders ? ctx.style.styled(headerToken, header) : header;
+        return formatCellLines(value, widths[index] ?? 0, overflow, wrapMode);
+    });
+    const headerHeight = headerLines.reduce((max, lines) => Math.max(max, lines.length), 1);
+    const fittedRows = rows.map((row) => {
+        const cells = widths.map((width, index) => {
+            return formatCellLines(row[index] ?? '', width, overflow, wrapMode);
+        });
+        const height = cells.reduce((max, lines) => Math.max(max, lines.length), 1);
+        return { cells, height };
+    });
+    return {
+        columns: columns.map((column, index) => ({
+            header: column.header ?? '',
+            width: widths[index] ?? 0,
+            align: column.align ?? 'left',
+        })),
+        widths,
+        headerLines,
+        headerHeight,
+        rows: fittedRows,
+        columnGap,
+        showHeader: tableData.showHeader,
+    };
+}
+function renderGridTable(model, options, ctx, variant, styled = true) {
+    const borderToken = options.borderToken ?? ctx.border('muted');
+    const bc = (s) => styled ? ctx.style.styled(borderToken, s) : s;
+    const chars = variant === 'box'
+        ? {
+            h: '\u2500',
+            v: '\u2502',
+            topLeft: '\u250c',
+            topMid: '\u252c',
+            topRight: '\u2510',
+            midLeft: '\u251c',
+            midMid: '\u253c',
+            midRight: '\u2524',
+            bottomLeft: '\u2514',
+            bottomMid: '\u2534',
+            bottomRight: '\u2518',
+        }
+        : {
+            h: '-',
+            v: '|',
+            topLeft: '+',
+            topMid: '+',
+            topRight: '+',
+            midLeft: '+',
+            midMid: '+',
+            midRight: '+',
+            bottomLeft: '+',
+            bottomMid: '+',
+            bottomRight: '+',
+        };
+    const hLine = (left, mid, right) => {
+        const segments = model.widths.map(w => chars.h.repeat(w + 2));
+        return bc(left + segments.join(mid) + right);
+    };
+    const top = hLine(chars.topLeft, chars.topMid, chars.topRight);
+    const midSep = hLine(chars.midLeft, chars.midMid, chars.midRight);
+    const bottom = hLine(chars.bottomLeft, chars.bottomMid, chars.bottomRight);
+    const hdrBgFill = styled ? makeBgFill(options.headerBgToken, ctx) : undefined;
+    const headerRows = Array.from({ length: model.headerHeight }, (_row, rowIndex) => {
+        const headerCells = model.columns.map((column, i) => ' ' + alignCell(model.headerLines[i]?.[rowIndex] ?? '', column.width, column.align) + ' ');
+        const rawHeaderRow = bc(chars.v) + headerCells.join(bc(chars.v)) + bc(chars.v);
+        return hdrBgFill ? hdrBgFill(rawHeaderRow) : rawHeaderRow;
+    });
+    const dataRows = model.rows.flatMap((row) => {
+        return Array.from({ length: row.height }, (_line, lineIndex) => {
+            const cells = model.columns.map((column, i) => ' ' + alignCell(row.cells[i]?.[lineIndex] ?? '', column.width, column.align) + ' ');
+            return bc(chars.v) + cells.join(bc(chars.v)) + bc(chars.v);
+        });
+    });
+    return model.showHeader
+        ? [top, ...headerRows, midSep, ...dataRows, bottom].join('\n')
+        : [top, ...dataRows, bottom].join('\n');
+}
+function renderBorderlessRow(model, cells, rowIndex) {
+    const gap = ' '.repeat(model.columnGap);
+    return model.columns
+        .map((column, index) => alignCell(cells[index]?.[rowIndex] ?? '', column.width, column.align))
+        .join(gap)
+        .trimEnd();
+}
+function renderRule(model, char, ctx, options) {
+    const borderToken = options.borderToken ?? ctx.border('muted');
+    const line = model.widths.map(width => char.repeat(width)).join(' '.repeat(model.columnGap)).trimEnd();
+    return ctx.style.styled(borderToken, line);
+}
+function renderRuledTable(model, options, ctx, includeRowRules) {
+    const lines = model.showHeader
+        ? [
+            ...Array.from({ length: model.headerHeight }, (_row, index) => {
+                return renderBorderlessRow(model, model.headerLines, index);
+            }),
+            renderRule(model, '\u2501', ctx, options),
+        ]
+        : [];
+    for (let rowIndex = 0; rowIndex < model.rows.length; rowIndex++) {
+        const row = model.rows[rowIndex];
+        for (let lineIndex = 0; lineIndex < row.height; lineIndex++) {
+            lines.push(renderBorderlessRow(model, row.cells, lineIndex));
+        }
+        if (includeRowRules && rowIndex < model.rows.length - 1) {
+            lines.push(renderRule(model, '\u2500', ctx, options));
+        }
+    }
+    return lines.join('\n');
+}
+function renderHeaderRuleTable(model) {
+    const lines = model.showHeader
+        ? [
+            ...Array.from({ length: model.headerHeight }, (_row, index) => {
+                return renderBorderlessRow(model, model.headerLines, index);
+            }),
+            model.widths.map(width => '-'.repeat(width)).join(' '.repeat(model.columnGap)).trimEnd(),
+        ]
+        : [];
+    for (const row of model.rows) {
+        for (let lineIndex = 0; lineIndex < row.height; lineIndex++) {
+            lines.push(renderBorderlessRow(model, row.cells, lineIndex));
+        }
+    }
+    return lines.join('\n');
+}
+function renderPlainTable(model) {
+    const lines = model.showHeader
+        ? Array.from({ length: model.headerHeight }, (_row, index) => {
+            return renderBorderlessRow(model, model.headerLines, index);
+        })
+        : [];
+    for (const row of model.rows) {
+        for (let lineIndex = 0; lineIndex < row.height; lineIndex++) {
+            lines.push(renderBorderlessRow(model, row.cells, lineIndex));
+        }
+    }
+    return lines.join('\n');
+}
+function markdownSeparator(width, align) {
+    const segmentWidth = Math.max(3, width + 2);
+    if (align === 'right')
+        return '-'.repeat(segmentWidth - 1) + ':';
+    if (align === 'center')
+        return ':' + '-'.repeat(segmentWidth - 2) + ':';
+    return '-'.repeat(segmentWidth);
+}
+function renderMarkdownTable(model) {
+    const renderWidths = model.columns.map(column => Math.max(1, column.width));
+    const rowLine = (cells, lineIndex) => {
+        return '|' + model.columns.map((column, index) => {
+            const value = cells[index]?.[lineIndex] ?? '';
+            return ' ' + alignCell(value, renderWidths[index], column.align) + ' ';
+        }).join('|') + '|';
+    };
+    const headerRows = Array.from({ length: model.headerHeight }, (_row, index) => {
+        return rowLine(model.headerLines, index);
+    });
+    const separator = '|' + model.columns.map((column, index) => {
+        return markdownSeparator(renderWidths[index], column.align);
+    }).join('|') + '|';
+    const rows = model.rows.flatMap((row) => {
+        return Array.from({ length: row.height }, (_line, index) => rowLine(row.cells, index));
+    });
+    return model.showHeader ? [...headerRows, separator, ...rows].join('\n') : rows.join('\n');
+}
+function renderExpandedTable(tableData, options, ctx) {
+    const borderToken = options.borderToken ?? ctx.border('muted');
+    const lines = [];
+    const columnLabel = (index) => {
+        return tableData.showHeader ? tableData.columns[index]?.header ?? '' : `Column ${index + 1}`;
+    };
+    const preferredLabelWidth = tableData.columns.reduce((max, _column, index) => {
+        return Math.max(max, visibleLength(columnLabel(index)));
+    }, 0);
+    const layout = options.layout ?? 'auto';
+    const targetWidth = resolveTargetWidth(options, ctx, layout);
+    const ruleWidth = targetWidth ?? 40;
+    const separator = targetWidth === undefined || targetWidth >= 3
+        ? ' | '
+        : ' '.repeat(Math.max(0, targetWidth - 1));
+    const availableContentWidth = targetWidth === undefined
+        ? undefined
+        : Math.max(0, targetWidth - separator.length);
+    const labelWidth = targetWidth === undefined
+        ? preferredLabelWidth
+        : Math.min(preferredLabelWidth, Math.floor((availableContentWidth ?? 0) / 2));
+    const valueWidth = targetWidth === undefined
+        ? undefined
+        : Math.max(0, targetWidth - labelWidth - separator.length);
+    const overflow = resolveOverflowBehavior(options.overflow, ctx.resolveBCSS({ type: 'Table', id: options.id, classes: options.class?.split(' ') }));
+    const wrapMode = options.wrap ?? 'word';
+    for (let rowIndex = 0; rowIndex < tableData.rows.length; rowIndex++) {
+        const title = `-[ RECORD ${rowIndex + 1} ]`;
+        const clippedTitle = targetWidth === undefined ? title : clipCellToWidth(title, ruleWidth);
+        lines.push(ctx.style.styled(borderToken, clippedTitle + '-'.repeat(Math.max(0, ruleWidth - visibleLength(clippedTitle)))));
+        const row = tableData.rows[rowIndex];
+        for (let columnIndex = 0; columnIndex < tableData.columns.length; columnIndex++) {
+            const rawLabel = columnLabel(columnIndex);
+            const label = padRight(targetWidth === undefined ? rawLabel : clipCellToWidth(rawLabel, labelWidth), labelWidth);
+            const rawValue = row[columnIndex] ?? '';
+            const valueLines = valueWidth === undefined
+                ? rawValue.split('\n')
+                : formatCellLines(rawValue, valueWidth, overflow, wrapMode);
+            for (let lineIndex = 0; lineIndex < valueLines.length; lineIndex++) {
+                const lineLabel = lineIndex === 0 ? label : ' '.repeat(labelWidth);
+                lines.push(`${lineLabel}${separator}${valueLines[lineIndex] ?? ''}`.trimEnd());
+            }
+        }
+    }
+    return lines.join('\n');
+}
+function markdownEscapeCell(value) {
+    return stripAnsi(String(value ?? ''))
+        .replace(/\\/g, '\\\\')
+        .replace(/\|/g, '\\|')
+        .replace(/\r\n?/g, '\n')
+        .replace(/\n/g, '<br>');
+}
+function markdownTableData(tableData) {
+    return {
+        columns: tableData.columns.map(column => ({
+            ...column,
+            header: markdownEscapeCell(column.header ?? ''),
+        })),
+        rows: tableData.rows.map(row => row.map(cell => markdownEscapeCell(cell))),
+        showHeader: tableData.showHeader,
+    };
+}
+function renderVisualTable(options, ctx, tableData, variant) {
+    if (variant === 'markdown') {
+        const markdownData = markdownTableData(tableData);
+        const markdownModel = buildFittedTable(options, ctx, markdownData, 'markdown', {
+            styleHeaders: false,
+        });
+        return renderMarkdownTable(markdownModel);
+    }
+    if (variant === 'expanded') {
+        return renderExpandedTable(tableData, options, ctx);
+    }
+    const model = buildFittedTable(options, ctx, tableData, variant);
+    switch (variant) {
+        case 'ascii-grid':
+            return renderGridTable(model, options, ctx, 'ascii-grid');
+        case 'ruled':
+            return renderRuledTable(model, options, ctx, true);
+        case 'header-rule':
+            return renderHeaderRuleTable(model);
+        case 'plain':
+            return renderPlainTable(model);
+        case 'definition':
+            return renderRuledTable(model, options, ctx, true);
+        case 'box':
+        default:
+            return renderGridTable(model, options, ctx, 'box');
+    }
+}
+function escapeTsvCell(value) {
+    return String(value ?? '')
+        .replace(/\\/g, '\\\\')
+        .replace(/\t/g, '\\t')
+        .replace(/\r/g, '\\r')
+        .replace(/\n/g, '\\n');
+}
+function escapeCsvCell(value) {
+    const text = String(value ?? '');
+    if (!/[",\r\n]/.test(text))
+        return text;
+    return `"${text.replace(/"/g, '""')}"`;
+}
+function renderSeparatedPipe(tableData, separator, escapeCell) {
+    const headerLine = tableData.columns.map(column => escapeCell(column.header ?? '')).join(separator);
+    const dataLines = tableData.rows.map(row => row.map(escapeCell).join(separator));
+    if (!tableData.showHeader)
+        return dataLines.join('\n');
+    return [headerLine, ...dataLines].join('\n');
+}
+function renderPipeTable(options, ctx, tableData) {
+    const format = options.pipeFormat ?? 'tsv';
+    if (format === 'csv')
+        return renderSeparatedPipe(tableData, ',', escapeCsvCell);
+    if (format === 'markdown') {
+        const markdownData = markdownTableData(tableData);
+        const markdownModel = buildFittedTable(options, ctx, markdownData, 'markdown', {
+            layout: options.layout ?? (options.width !== undefined || options.maxWidth !== undefined ? 'auto' : 'intrinsic'),
+            styleHeaders: false,
+        });
+        return renderMarkdownTable(markdownModel);
+    }
+    if (format === 'ascii-grid') {
+        const model = buildFittedTable(options, ctx, tableData, 'ascii-grid', {
+            layout: options.layout ?? (options.width !== undefined || options.maxWidth !== undefined ? 'auto' : 'intrinsic'),
+            styleHeaders: false,
+        });
+        return renderGridTable(model, options, ctx, 'ascii-grid', false);
+    }
+    return renderSeparatedPipe(tableData, '\t', escapeTsvCell);
+}
+export function table(optionsOrColumns, rowData, context) {
+    let options;
+    if (isTableOptions(optionsOrColumns)) {
+        options = optionsOrColumns;
+    }
+    else {
+        options = { columns: [...optionsOrColumns], rows: rowData ?? [], ctx: context };
+    }
     const ctx = resolveCtx(options.ctx);
-    const columns = options.columns ?? [];
-    const rows = (options.rows ?? []).map(row => (row ?? []).map(cell => cell ?? ''));
+    const tableData = normalizeTable(options);
     return renderByMode(ctx.mode, {
-        pipe: () => {
-            const headerLine = columns.map((c) => c.header ?? '').join('\t');
-            const dataLines = rows.map((row) => row.join('\t'));
-            return [headerLine, ...dataLines].join('\n');
-        },
+        pipe: () => renderPipeTable(options, ctx, tableData),
         accessible: () => {
             const lines = [];
-            for (let i = 0; i < rows.length; i++) {
-                const row = rows[i];
-                const pairs = columns.map((col, j) => `${col.header ?? ''}=${row[j] ?? ''}`);
+            for (let i = 0; i < tableData.rows.length; i++) {
+                const row = tableData.rows[i];
+                const pairs = tableData.columns.map((col, j) => {
+                    const label = tableData.showHeader ? col.header ?? '' : `Column ${j + 1}`;
+                    return `${label}=${row[j] ?? ''}`;
+                });
                 lines.push(`Row ${i + 1}: ${pairs.join(', ')}`);
             }
             return lines.join('\n');
         },
-        interactive: () => {
-            const headerToken = options.headerToken ?? ctx.ui('tableHeader');
-            const borderToken = options.borderToken ?? ctx.border('muted');
-            const overflow = resolveOverflowBehavior(options.overflow, ctx.resolveBCSS({ type: 'Table', id: options.id, classes: options.class?.split(' ') }));
-            const bc = (s) => ctx.style.styled(borderToken, s);
-            const colWidths = columns.map((col, i) => {
-                const normalizedWidth = normalizeColumnWidth(col.width);
-                if (normalizedWidth !== undefined)
-                    return normalizedWidth;
-                let max = visibleLength(col.header ?? '');
-                for (const row of rows) {
-                    const cell = row[i] ?? '';
-                    max = Math.max(max, visibleLength(cell));
-                }
-                return max;
-            });
-            const h = '\u2500';
-            const v = '\u2502';
-            const hLine = (left, mid, right) => {
-                const segments = colWidths.map((w) => h.repeat(w + 2));
-                return bc(left + segments.join(mid) + right);
-            };
-            const top = hLine('\u250c', '\u252c', '\u2510');
-            const midSep = hLine('\u251c', '\u253c', '\u2524');
-            const bottom = hLine('\u2514', '\u2534', '\u2518');
-            const hdrBgFill = makeBgFill(options.headerBgToken, ctx);
-            const headerLinesByColumn = columns.map((col, i) => formatCellLines(ctx.style.styled(headerToken, col.header ?? ''), colWidths[i], overflow, col.width !== undefined));
-            const headerHeight = headerLinesByColumn.reduce((max, lines) => Math.max(max, lines.length), 1);
-            const headerRows = Array.from({ length: headerHeight }, (_row, rowIndex) => {
-                const headerCells = columns.map((_col, i) => ' ' + padRight(headerLinesByColumn[i][rowIndex] ?? '', colWidths[i]) + ' ');
-                const rawHeaderRow = bc(v) + headerCells.join(bc(v)) + bc(v);
-                return hdrBgFill ? hdrBgFill(rawHeaderRow) : rawHeaderRow;
-            });
-            const dataRows = rows.flatMap((row) => {
-                const cellLines = colWidths.map((w, i) => formatCellLines(row[i] ?? '', w, overflow, columns[i]?.width !== undefined));
-                const rowHeight = cellLines.reduce((max, lines) => Math.max(max, lines.length), 1);
-                return Array.from({ length: rowHeight }, (_line, lineIndex) => {
-                    const cells = colWidths.map((w, i) => ' ' + padRight(cellLines[i][lineIndex] ?? '', w) + ' ');
-                    return bc(v) + cells.join(bc(v)) + bc(v);
-                });
-            });
-            const lines = [top, ...headerRows, midSep, ...dataRows, bottom];
-            return lines.join('\n');
-        },
+        interactive: () => renderVisualTable(options, ctx, tableData, options.variant ?? 'box'),
     }, options);
 }
 //# sourceMappingURL=table.js.map