mu-harness 0.16.3

package/script/tui/src/layout/ansi.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLine = parseLine;
+exports.cellsToAnsi = cellsToAnsi;
+const utils_1 = require("../utils");
+const cell_1 = require("./cell");
+const color_1 = require("./color");
+function parseLine(line) {
+    const cells = [];
+    let style = (0, cell_1.defaultStyle)();
+    let i = 0;
+    const n = line.length;
+    while (i < n) {
+        const code = line.codePointAt(i);
+        if (code === undefined) {
+            i++;
+            continue;
+        }
+        if (code === 0x1b) {
+            i = consumeEscape(line, i + 1, (newStyle) => {
+                style = newStyle;
+            }, style);
+            continue;
+        }
+        const w = (0, utils_1.charWidth)(code);
+        const step = code > 0xffff ? 2 : 1;
+        const grapheme = line.slice(i, i + step);
+        i += step;
+        if (w === 0) {
+            continue;
+        }
+        cells.push({ grapheme, width: w, style: cloneStyle(style) });
+        if (w === 2)
+            cells.push((0, cell_1.continuationCell)());
+    }
+    return cells;
+}
+function cellsToAnsi(cells) {
+    let out = '';
+    let prev = null;
+    let prevLink;
+    let needsReset = false;
+    for (const cell of cells) {
+        if (cell.width === 0)
+            continue;
+        if (!prev || !(0, cell_1.styleEqual)(prev, cell.style)) {
+            const delta = sgrDelta(prev, cell.style);
+            if (delta.length > 0) {
+                out += delta;
+                needsReset = true;
+            }
+            prev = cell.style;
+        }
+        if (cell.style.link !== prevLink) {
+            out += linkEscape(cell.style.link);
+            prevLink = cell.style.link;
+            if (cell.style.link)
+                needsReset = true;
+        }
+        out += cell.grapheme || ' ';
+    }
+    if (needsReset)
+        out += '\x1b[0m';
+    if (prevLink)
+        out += '\x1b]8;;\x07';
+    return out;
+}
+function consumeEscape(input, index, setStyle, currentStyle) {
+    if (index >= input.length)
+        return index;
+    const next = input.charCodeAt(index);
+    if (next === 0x5b) {
+        let j = index + 1;
+        while (j < input.length) {
+            const c = input.charCodeAt(j);
+            if (c >= 0x40 && c <= 0x7e) {
+                const params = input.slice(index + 1, j);
+                if (c === 0x6d) {
+                    setStyle(applySgr(currentStyle, params));
+                }
+                return j + 1;
+            }
+            j++;
+        }
+        return input.length;
+    }
+    if (next === 0x5d) {
+        let j = index + 1;
+        while (j < input.length) {
+            const c = input.charCodeAt(j);
+            if (c === 0x07) {
+                const payload = input.slice(index + 1, j);
+                applyOsc(payload, setStyle, currentStyle);
+                return j + 1;
+            }
+            if (c === 0x1b && j + 1 < input.length && input.charCodeAt(j + 1) === 0x5c) {
+                const payload = input.slice(index + 1, j);
+                applyOsc(payload, setStyle, currentStyle);
+                return j + 2;
+            }
+            j++;
+        }
+        return input.length;
+    }
+    if (next === 0x50 || next === 0x5e || next === 0x5f || next === 0x58) {
+        let j = index + 1;
+        while (j < input.length - 1) {
+            if (input.charCodeAt(j) === 0x1b && input.charCodeAt(j + 1) === 0x5c) {
+                return j + 2;
+            }
+            j++;
+        }
+        return input.length;
+    }
+    return index + 1;
+}
+function applyOsc(payload, setStyle, current) {
+    if (payload.startsWith('8;')) {
+        const semi = payload.indexOf(';', 2);
+        const url = semi === -1 ? '' : payload.slice(semi + 1);
+        const next = { ...current, link: url.length > 0 ? url : undefined };
+        setStyle(next);
+    }
+}
+function applySgr(current, params) {
+    const next = cloneStyle(current);
+    if (params.length === 0)
+        return resetStyle(next);
+    const parts = params.split(';');
+    let i = 0;
+    while (i < parts.length) {
+        const n = parts[i] === '' ? 0 : Number.parseInt(parts[i], 10);
+        if (Number.isNaN(n)) {
+            i++;
+            continue;
+        }
+        switch (n) {
+            case 0:
+                resetStyle(next);
+                break;
+            case 1:
+                next.bold = true;
+                break;
+            case 2:
+                next.dim = true;
+                break;
+            case 3:
+                next.italic = true;
+                break;
+            case 4:
+                next.underline = true;
+                break;
+            case 5:
+            case 6:
+                next.blink = true;
+                break;
+            case 7:
+                next.reverse = true;
+                break;
+            case 9:
+                next.strikethrough = true;
+                break;
+            case 22:
+                next.bold = false;
+                next.dim = false;
+                break;
+            case 23:
+                next.italic = false;
+                break;
+            case 24:
+                next.underline = false;
+                break;
+            case 25:
+                next.blink = false;
+                break;
+            case 27:
+                next.reverse = false;
+                break;
+            case 29:
+                next.strikethrough = false;
+                break;
+            case 38: {
+                const consumed = parseExtendedColor(parts, i + 1, (rgba) => {
+                    next.fg = rgba;
+                });
+                i += consumed;
+                break;
+            }
+            case 48: {
+                const consumed = parseExtendedColor(parts, i + 1, (rgba) => {
+                    next.bg = rgba;
+                });
+                i += consumed;
+                break;
+            }
+            case 39:
+                next.fg = { ...color_1.DEFAULT_FG };
+                break;
+            case 49:
+                next.bg = { ...color_1.DEFAULT_BG };
+                break;
+            default:
+                if (n >= 30 && n <= 37)
+                    next.fg = indexed(n - 30);
+                else if (n >= 40 && n <= 47)
+                    next.bg = indexed(n - 40);
+                else if (n >= 90 && n <= 97)
+                    next.fg = indexed(n - 90 + 8);
+                else if (n >= 100 && n <= 107)
+                    next.bg = indexed(n - 100 + 8);
+                break;
+        }
+        i++;
+    }
+    return next;
+}
+function parseExtendedColor(parts, from, set) {
+    const mode = parts[from] === undefined ? -1 : Number.parseInt(parts[from], 10);
+    if (mode === 5) {
+        const idx = Number.parseInt(parts[from + 1] ?? '0', 10);
+        set((0, color_1.indexedColor)(Number.isNaN(idx) ? 0 : idx));
+        return 2;
+    }
+    if (mode === 2) {
+        const r = Number.parseInt(parts[from + 1] ?? '0', 10);
+        const g = Number.parseInt(parts[from + 2] ?? '0', 10);
+        const b = Number.parseInt(parts[from + 3] ?? '0', 10);
+        set((0, color_1.rgbColor)(clamp255(r), clamp255(g), clamp255(b)));
+        return 4;
+    }
+    return 0;
+}
+function indexed(index) {
+    const [r, g, b] = (0, color_1.palette256)(index);
+    return { r, g, b, a: 1, intent: 'indexed', index };
+}
+function clamp255(n) {
+    if (Number.isNaN(n))
+        return 0;
+    return Math.max(0, Math.min(255, n));
+}
+function resetStyle(style) {
+    style.fg = { ...color_1.DEFAULT_FG };
+    style.bg = { ...color_1.DEFAULT_BG };
+    style.bold = false;
+    style.dim = false;
+    style.italic = false;
+    style.underline = false;
+    style.strikethrough = false;
+    style.reverse = false;
+    style.blink = false;
+    style.link = undefined;
+    return style;
+}
+function cloneStyle(style) {
+    return {
+        fg: { ...style.fg },
+        bg: { ...style.bg },
+        bold: style.bold,
+        dim: style.dim,
+        italic: style.italic,
+        underline: style.underline,
+        strikethrough: style.strikethrough,
+        reverse: style.reverse,
+        blink: style.blink,
+        link: style.link,
+    };
+}
+function sgrDelta(prev, next) {
+    const params = [];
+    if (!prev) {
+        if (next.bold)
+            params.push('1');
+        if (next.dim)
+            params.push('2');
+        if (next.italic)
+            params.push('3');
+        if (next.underline)
+            params.push('4');
+        if (next.blink)
+            params.push('5');
+        if (next.reverse)
+            params.push('7');
+        if (next.strikethrough)
+            params.push('9');
+        if (next.fg.intent !== 'default')
+            params.push((0, color_1.rgbaToSgr)(next.fg, 'fg'));
+        if (next.bg.intent !== 'default' && next.bg.a > 0)
+            params.push((0, color_1.rgbaToSgr)(next.bg, 'bg'));
+        if (params.length === 0)
+            return '';
+        return `\x1b[${params.join(';')}m`;
+    }
+    if (prev.bold !== next.bold || prev.dim !== next.dim) {
+        if (!next.bold && !next.dim && (prev.bold || prev.dim))
+            params.push('22');
+        if (next.bold && !prev.bold)
+            params.push('1');
+        if (next.dim && !prev.dim)
+            params.push('2');
+    }
+    if (prev.italic !== next.italic)
+        params.push(next.italic ? '3' : '23');
+    if (prev.underline !== next.underline)
+        params.push(next.underline ? '4' : '24');
+    if (prev.blink !== next.blink)
+        params.push(next.blink ? '5' : '25');
+    if (prev.reverse !== next.reverse)
+        params.push(next.reverse ? '7' : '27');
+    if (prev.strikethrough !== next.strikethrough)
+        params.push(next.strikethrough ? '9' : '29');
+    if (!rgbaShallowEqual(prev.fg, next.fg))
+        params.push((0, color_1.rgbaToSgr)(next.fg, 'fg'));
+    if (!rgbaShallowEqual(prev.bg, next.bg))
+        params.push((0, color_1.rgbaToSgr)(next.bg, 'bg'));
+    if (params.length === 0)
+        return '';
+    return `\x1b[${params.join(';')}m`;
+}
+function rgbaShallowEqual(a, b) {
+    return (a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a && a.intent === b.intent && a.index === b.index);
+}
+function linkEscape(link) {
+    if (!link)
+        return '\x1b]8;;\x07';
+    return `\x1b]8;;${link}\x07`;
+}

package/script/tui/src/layout/cell.d.ts

@@ -0,0 +1,24 @@
+import { type Rgba } from './color';
+export interface CellStyle {
+    fg: Rgba;
+    bg: Rgba;
+    bold: boolean;
+    dim: boolean;
+    italic: boolean;
+    underline: boolean;
+    strikethrough: boolean;
+    reverse: boolean;
+    blink: boolean;
+    link?: string;
+}
+export interface Cell {
+    grapheme: string;
+    width: 0 | 1 | 2;
+    style: CellStyle;
+}
+export declare const DEFAULT_STYLE: CellStyle;
+export declare function defaultStyle(): CellStyle;
+export declare function emptyCell(): Cell;
+export declare function continuationCell(): Cell;
+export declare function styleEqual(a: CellStyle, b: CellStyle): boolean;
+export declare function cellEqual(a: Cell, b: Cell): boolean;

package/script/tui/src/layout/cell.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_STYLE = void 0;
+exports.defaultStyle = defaultStyle;
+exports.emptyCell = emptyCell;
+exports.continuationCell = continuationCell;
+exports.styleEqual = styleEqual;
+exports.cellEqual = cellEqual;
+const color_1 = require("./color");
+exports.DEFAULT_STYLE = {
+    fg: color_1.DEFAULT_FG,
+    bg: color_1.DEFAULT_BG,
+    bold: false,
+    dim: false,
+    italic: false,
+    underline: false,
+    strikethrough: false,
+    reverse: false,
+    blink: false,
+};
+function defaultStyle() {
+    return {
+        fg: color_1.DEFAULT_FG,
+        bg: color_1.DEFAULT_BG,
+        bold: false,
+        dim: false,
+        italic: false,
+        underline: false,
+        strikethrough: false,
+        reverse: false,
+        blink: false,
+    };
+}
+function emptyCell() {
+    return { grapheme: ' ', width: 1, style: defaultStyle() };
+}
+function continuationCell() {
+    return { grapheme: '', width: 0, style: defaultStyle() };
+}
+function styleEqual(a, b) {
+    return (a.bold === b.bold &&
+        a.dim === b.dim &&
+        a.italic === b.italic &&
+        a.underline === b.underline &&
+        a.strikethrough === b.strikethrough &&
+        a.reverse === b.reverse &&
+        a.blink === b.blink &&
+        a.link === b.link &&
+        (0, color_1.rgbaEqual)(a.fg, b.fg) &&
+        (0, color_1.rgbaEqual)(a.bg, b.bg));
+}
+function cellEqual(a, b) {
+    return a.grapheme === b.grapheme && a.width === b.width && styleEqual(a.style, b.style);
+}

package/script/tui/src/layout/cellbuffer.d.ts

@@ -0,0 +1,29 @@
+import { type Cell } from './cell';
+import { type Rgba } from './color';
+import type { BorderStyle, Rect } from './types';
+export interface CellBuffer {
+    width: number;
+    height: number;
+    cells: Cell[];
+    backdropColor: Rgba;
+    opacityStack: number[];
+}
+export declare function createCellBuffer(width: number, height: number, backdropColor?: Rgba): CellBuffer;
+export declare function setBackdropColor(buf: CellBuffer, color: Rgba): void;
+export declare function pushOpacity(buf: CellBuffer, opacity: number): void;
+export declare function popOpacity(buf: CellBuffer): void;
+export declare function effectiveOpacity(buf: CellBuffer): number;
+export declare function getCell(buf: CellBuffer, x: number, y: number): Cell;
+export declare function compositeCell(buf: CellBuffer, x: number, y: number, incoming: Cell, opacity?: number): void;
+export declare function fillBackground(buf: CellBuffer, rect: Rect, color: Rgba, clip: Rect): void;
+export declare function writeCells(buf: CellBuffer, x: number, y: number, cells: Cell[], clip: Rect): void;
+export declare function drawBorderCells(buf: CellBuffer, rect: Rect, style: BorderStyle | true, clip: Rect): void;
+export declare function cellBufferToLines(buf: CellBuffer): string[];
+export declare function bufferUsedHeight(buf: CellBuffer): number;
+export interface DiffRun {
+    y: number;
+    x: number;
+    cells: Cell[];
+    clear?: boolean;
+}
+export declare function diffBuffer(prev: CellBuffer, next: CellBuffer, maxRow: number, mergeGap?: number): DiffRun[];