mu-harness 0.16.3

package/script/tui/src/parser.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalInputParser = void 0;
+const keyboard_1 = require("./keyboard");
+const ESC = '\x1b';
+const PASTE_START = '\x1b[200~';
+const PASTE_END = '\x1b[201~';
+class TerminalInputParser {
+    options;
+    buffer = '';
+    paste = '';
+    inPaste = false;
+    pasteOverflowed = false;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    feed(data) {
+        this.buffer += data;
+        const events = [];
+        while (this.buffer.length > 0) {
+            if (this.inPaste) {
+                const end = this.buffer.indexOf(PASTE_END);
+                if (end === -1) {
+                    if (!this.pasteOverflowed) {
+                        this.paste += this.buffer;
+                        if (this.paste.length > this.maxPasteBytes) {
+                            this.paste = this.paste.slice(0, this.maxPasteBytes);
+                            this.pasteOverflowed = true;
+                        }
+                    }
+                    this.buffer = '';
+                    break;
+                }
+                if (!this.pasteOverflowed) {
+                    this.paste += this.buffer.slice(0, end);
+                    if (this.paste.length > this.maxPasteBytes) {
+                        this.paste = this.paste.slice(0, this.maxPasteBytes);
+                    }
+                }
+                this.buffer = this.buffer.slice(end + PASTE_END.length);
+                events.push({ type: 'paste', text: this.paste, raw: `${PASTE_START}${this.paste}${PASTE_END}` });
+                this.paste = '';
+                this.inPaste = false;
+                this.pasteOverflowed = false;
+                continue;
+            }
+            if (this.buffer.startsWith(PASTE_START)) {
+                this.buffer = this.buffer.slice(PASTE_START.length);
+                this.inPaste = true;
+                continue;
+            }
+            const token = takeToken(this.buffer);
+            if (token === null) {
+                if (this.buffer.length > this.maxBufferBytes) {
+                    events.push({
+                        type: 'terminalResponse',
+                        raw: this.buffer.slice(0, this.maxBufferBytes),
+                        sequence: 'unknown',
+                    });
+                    this.buffer = '';
+                    continue;
+                }
+                break;
+            }
+            this.buffer = this.buffer.slice(token.length);
+            const event = (0, keyboard_1.parseInput)(token);
+            if (event)
+                events.push(event);
+        }
+        return events;
+    }
+    flushPending() {
+        if (this.buffer.length === 0)
+            return [];
+        const raw = this.buffer;
+        this.buffer = '';
+        const event = (0, keyboard_1.parseInput)(raw);
+        return event ? [event] : [{ type: 'terminalResponse', raw, sequence: 'unknown' }];
+    }
+    hasPending() {
+        return this.buffer.length > 0;
+    }
+    get maxBufferBytes() {
+        return this.options.maxBufferBytes ?? 64 * 1024;
+    }
+    get maxPasteBytes() {
+        return this.options.maxPasteBytes ?? 1024 * 1024;
+    }
+}
+exports.TerminalInputParser = TerminalInputParser;
+function takeToken(input) {
+    if (input.length === 0)
+        return null;
+    if (!input.startsWith(ESC))
+        return takeTextOrControl(input);
+    if (input.length === 1)
+        return null;
+    const prefix = input.slice(0, 2);
+    if (prefix === '\x1b[')
+        return takeCsi(input);
+    if (prefix === '\x1b]')
+        return takeString(input, true);
+    if (prefix === '\x1bP' || prefix === '\x1b_' || prefix === '\x1b^' || prefix === '\x1bX') {
+        return takeString(input, false);
+    }
+    if (prefix === '\x1bO')
+        return input.length >= 3 ? input.slice(0, 3) : null;
+    return Array.from(input).length >= 2 ? ESC + Array.from(input.slice(1))[0] : null;
+}
+function takeTextOrControl(input) {
+    const first = input.codePointAt(0) ?? 0;
+    if (first < 0x20 || first === 0x7f)
+        return input.slice(0, 1);
+    let end = 0;
+    for (const ch of input) {
+        const code = ch.codePointAt(0) ?? 0;
+        if (ch === ESC || code < 0x20 || code === 0x7f)
+            break;
+        end += ch.length;
+    }
+    return input.slice(0, end);
+}
+function takeCsi(input) {
+    for (let i = 2; i < input.length; i++) {
+        const code = input.charCodeAt(i);
+        if (code >= 0x40 && code <= 0x7e) {
+            return input.slice(0, i + 1);
+        }
+    }
+    return null;
+}
+function takeString(input, allowBel) {
+    for (let i = 2; i < input.length; i++) {
+        if (allowBel && input.charCodeAt(i) === 0x07)
+            return input.slice(0, i + 1);
+        if (input[i] === ESC && input[i + 1] === '\\')
+            return input.slice(0, i + 2);
+    }
+    return null;
+}

package/script/tui/src/renderer.d.ts

@@ -0,0 +1,32 @@
+import type { Rgba } from './layout/color';
+import { type Component, type SurfaceEntry } from './surface';
+import type { Terminal } from './types/terminal';
+export interface RendererHost {
+    getRoot(): Component | null;
+    isFocused(component: Component): boolean;
+    setEntries(entries: SurfaceEntry[]): void;
+    getBackdropColor(): Rgba;
+}
+export declare class Renderer {
+    private readonly terminal;
+    private readonly host;
+    private readonly useSynchronizedOutput;
+    private previousBuffer;
+    private previousUsedHeight;
+    private renderRequested;
+    private renderTimer;
+    private lastRenderAt;
+    private stopped;
+    private static readonly MIN_RENDER_INTERVAL_MS;
+    constructor(terminal: Terminal, host: RendererHost, useSynchronizedOutput: boolean);
+    setStopped(stopped: boolean): void;
+    requestRender(force?: boolean): void;
+    private scheduleRender;
+    private renderFrame;
+    doRender(): void;
+    private fullRender;
+    private cellDiffRender;
+    moveCursorAfterRenderedContent(): void;
+    private frameStart;
+    private frameEnd;
+}

package/script/tui/src/renderer.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Renderer = void 0;
+const node_perf_hooks_1 = require("node:perf_hooks");
+const node_process_1 = __importDefault(require("node:process"));
+const ansi_1 = require("./layout/ansi");
+const cellbuffer_1 = require("./layout/cellbuffer");
+const surface_1 = require("./surface");
+class Renderer {
+    terminal;
+    host;
+    useSynchronizedOutput;
+    previousBuffer = null;
+    previousUsedHeight = 0;
+    renderRequested = false;
+    renderTimer;
+    lastRenderAt = 0;
+    stopped = false;
+    static MIN_RENDER_INTERVAL_MS = 16;
+    constructor(terminal, host, useSynchronizedOutput) {
+        this.terminal = terminal;
+        this.host = host;
+        this.useSynchronizedOutput = useSynchronizedOutput;
+    }
+    setStopped(stopped) {
+        this.stopped = stopped;
+        if (stopped && this.renderTimer) {
+            clearTimeout(this.renderTimer);
+            this.renderTimer = undefined;
+        }
+    }
+    requestRender(force = false) {
+        if (force) {
+            this.previousBuffer = null;
+            this.previousUsedHeight = 0;
+            if (this.renderTimer) {
+                clearTimeout(this.renderTimer);
+                this.renderTimer = undefined;
+            }
+            this.renderRequested = true;
+            node_process_1.default.nextTick(() => {
+                if (this.stopped || !this.renderRequested)
+                    return;
+                this.renderRequested = false;
+                this.lastRenderAt = node_perf_hooks_1.performance.now();
+                this.doRender();
+            });
+            return;
+        }
+        if (this.renderRequested)
+            return;
+        this.renderRequested = true;
+        node_process_1.default.nextTick(() => this.scheduleRender());
+    }
+    scheduleRender() {
+        if (this.stopped || this.renderTimer || !this.renderRequested)
+            return;
+        const elapsed = node_perf_hooks_1.performance.now() - this.lastRenderAt;
+        const delay = Math.max(0, Renderer.MIN_RENDER_INTERVAL_MS - elapsed);
+        this.renderTimer = setTimeout(() => {
+            this.renderTimer = undefined;
+            if (this.stopped || !this.renderRequested)
+                return;
+            this.renderRequested = false;
+            this.lastRenderAt = node_perf_hooks_1.performance.now();
+            this.doRender();
+            if (this.renderRequested) {
+                this.scheduleRender();
+            }
+        }, delay);
+    }
+    renderFrame(width, height) {
+        const backdrop = this.host.getBackdropColor();
+        const buffer = (0, cellbuffer_1.createCellBuffer)(width, height, backdrop);
+        (0, cellbuffer_1.setBackdropColor)(buffer, backdrop);
+        const root = this.host.getRoot();
+        if (root) {
+            this.host.setEntries((0, surface_1.renderToBuffer)(root, buffer, (component) => this.host.isFocused(component)));
+        }
+        else {
+            this.host.setEntries([]);
+        }
+        return buffer;
+    }
+    doRender() {
+        if (this.stopped)
+            return;
+        const width = this.terminal.columns;
+        const height = this.terminal.rows;
+        const buffer = this.renderFrame(width, height);
+        const usedHeight = (0, cellbuffer_1.bufferUsedHeight)(buffer);
+        const prev = this.previousBuffer;
+        const sizeChanged = prev !== null && (prev.width !== width || prev.height !== height);
+        if (prev === null || sizeChanged || usedHeight > this.previousUsedHeight) {
+            this.fullRender(buffer, usedHeight, sizeChanged);
+        }
+        else {
+            this.cellDiffRender(prev, buffer, usedHeight);
+        }
+        this.previousBuffer = buffer;
+        this.previousUsedHeight = usedHeight;
+    }
+    fullRender(buffer, usedHeight, clear) {
+        const lines = (0, cellbuffer_1.cellBufferToLines)(buffer).slice(0, usedHeight);
+        const reset = '\x1b[0m\x1b]8;;\x07';
+        for (let i = 0; i < lines.length; i++)
+            lines[i] += reset;
+        let out = this.frameStart();
+        if (clear) {
+            out += '\x1b[2J\x1b[H\x1b[3J';
+        }
+        else if (this.previousBuffer !== null) {
+            out += '\x1b8';
+        }
+        for (let i = 0; i < lines.length; i++) {
+            if (i > 0)
+                out += '\r\n';
+            out += lines[i];
+        }
+        if (lines.length > 1) {
+            out += `\r\x1b[${lines.length - 1}A`;
+        }
+        else {
+            out += '\r';
+        }
+        out += '\x1b7';
+        out += this.frameEnd();
+        this.terminal.write(out);
+    }
+    cellDiffRender(prev, next, usedHeight) {
+        const maxRow = Math.max(usedHeight, this.previousUsedHeight);
+        const runs = (0, cellbuffer_1.diffBuffer)(prev, next, maxRow);
+        if (runs.length === 0)
+            return;
+        let out = this.frameStart();
+        let curRow = -1;
+        for (const run of runs) {
+            if (run.y !== curRow) {
+                out += '\x1b8';
+                if (run.y > 0)
+                    out += `\x1b[${run.y}B`;
+                curRow = run.y;
+            }
+            if (run.clear) {
+                out += '\x1b[0m\x1b[2K';
+            }
+            else {
+                out += `\x1b[${run.x + 1}G`;
+                out += (0, ansi_1.cellsToAnsi)(run.cells);
+            }
+        }
+        out += '\x1b8';
+        out += this.frameEnd();
+        this.terminal.write(out);
+    }
+    moveCursorAfterRenderedContent() {
+        if (this.previousBuffer === null)
+            return;
+        let out = '';
+        if (this.previousUsedHeight > 0)
+            out += `\x1b[${this.previousUsedHeight}B`;
+        out += '\r\n';
+        this.terminal.write(out);
+    }
+    frameStart() {
+        return this.useSynchronizedOutput ? '\x1b[?2026h' : '';
+    }
+    frameEnd() {
+        return this.useSynchronizedOutput ? '\x1b[?2026l' : '';
+    }
+}
+exports.Renderer = Renderer;

package/script/tui/src/surface.d.ts

@@ -0,0 +1,27 @@
+import type { InputEvent } from './events';
+import { type CellBuffer } from './layout/cellbuffer';
+import type { Color, Rect } from './layout/types';
+export interface Component {
+    render(surface: Surface): void;
+    handleInput?(event: InputEvent): void;
+    wantsKeyRelease?: boolean;
+}
+export interface Surface {
+    readonly width: number;
+    readonly height: number;
+    readonly focused: boolean;
+    text(x: number, y: number, value: string): void;
+    fill(rect: Rect, color: Color, opacity?: number): void;
+    measure(child: Component, width: number): number;
+    child(child: Component, rect: Rect, opts?: {
+        opacity?: number;
+        focused?: boolean;
+    }): void;
+}
+export interface SurfaceEntry {
+    component: Component;
+    rect: Rect;
+}
+export declare function measure(component: Component, width: number): number;
+export declare function measureWidth(component: Component, maxWidth: number): number;
+export declare function renderToBuffer(component: Component, buffer: CellBuffer, isFocused?: (component: Component) => boolean): SurfaceEntry[];

package/script/tui/src/surface.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measure = measure;
+exports.measureWidth = measureWidth;
+exports.renderToBuffer = renderToBuffer;
+const ansi_1 = require("./layout/ansi");
+const cellbuffer_1 = require("./layout/cellbuffer");
+const color_1 = require("./layout/color");
+const insets_1 = require("./layout/insets");
+const utils_1 = require("./utils");
+class BufferSurface {
+    env;
+    ox;
+    oy;
+    width;
+    height;
+    clip;
+    focused;
+    constructor(env, ox, oy, width, height, clip, focused) {
+        this.env = env;
+        this.ox = ox;
+        this.oy = oy;
+        this.width = width;
+        this.height = height;
+        this.clip = clip;
+        this.focused = focused;
+    }
+    text(x, y, value) {
+        if (y < 0 || y >= this.height)
+            return;
+        (0, cellbuffer_1.writeCells)(this.env.buffer, this.ox + x, this.oy + y, (0, ansi_1.parseLine)(value), this.clip);
+    }
+    fill(rect, color, opacity = 1) {
+        const abs = { x: this.ox + rect.x, y: this.oy + rect.y, width: rect.width, height: rect.height };
+        (0, cellbuffer_1.fillBackground)(this.env.buffer, abs, (0, color_1.colorToRgba)(color, opacity), this.clip);
+    }
+    measure(child, width) {
+        return measure(child, width);
+    }
+    child(child, rect, opts) {
+        const ox = this.ox + rect.x;
+        const oy = this.oy + rect.y;
+        const abs = { x: ox, y: oy, width: rect.width, height: rect.height };
+        const clip = (0, insets_1.intersectRect)(this.clip, abs);
+        const focused = opts?.focused ?? this.env.isFocused(child);
+        const sub = new BufferSurface(this.env, ox, oy, rect.width, rect.height, clip, focused);
+        this.env.entries.push({ component: child, rect: abs });
+        const dim = opts?.opacity !== undefined && opts.opacity < 1;
+        if (dim)
+            (0, cellbuffer_1.pushOpacity)(this.env.buffer, opts.opacity);
+        child.render(sub);
+        if (dim)
+            (0, cellbuffer_1.popOpacity)(this.env.buffer);
+    }
+}
+class ProbeSurface {
+    width;
+    maxRow = 0;
+    maxCol = 0;
+    height = Number.POSITIVE_INFINITY;
+    focused = false;
+    constructor(width) {
+        this.width = width;
+    }
+    bumpRow(row) {
+        if (row > this.maxRow)
+            this.maxRow = row;
+    }
+    bumpCol(col) {
+        if (col > this.maxCol)
+            this.maxCol = col;
+    }
+    text(x, y, value) {
+        this.bumpRow(y + value.split('\n').length);
+        let width = 0;
+        for (const line of value.split('\n')) {
+            const lineWidth = (0, utils_1.visibleWidth)(line);
+            if (lineWidth > width)
+                width = lineWidth;
+        }
+        this.bumpCol(x + width);
+    }
+    fill(rect) {
+        if (Number.isFinite(rect.height))
+            this.bumpRow(rect.y + rect.height);
+        if (Number.isFinite(rect.width))
+            this.bumpCol(rect.x + rect.width);
+    }
+    measure(child, width) {
+        return measure(child, width);
+    }
+    child(_child, rect) {
+        if (Number.isFinite(rect.height))
+            this.bumpRow(rect.y + rect.height);
+        if (Number.isFinite(rect.width))
+            this.bumpCol(rect.x + rect.width);
+    }
+}
+function measure(component, width) {
+    const probe = new ProbeSurface(Math.max(0, width));
+    component.render(probe);
+    return probe.maxRow;
+}
+function measureWidth(component, maxWidth) {
+    const probe = new ProbeSurface(Math.max(0, maxWidth));
+    component.render(probe);
+    return probe.maxCol;
+}
+function renderToBuffer(component, buffer, isFocused = () => false) {
+    const entries = [];
+    const env = { buffer, isFocused, entries };
+    const clip = { x: 0, y: 0, width: buffer.width, height: buffer.height };
+    component.render(new BufferSurface(env, 0, 0, buffer.width, buffer.height, clip, false));
+    return entries;
+}

package/script/tui/src/terminal.d.ts

@@ -0,0 +1,48 @@
+import { type Capabilities, type PartialCapabilities } from './capabilities';
+import type { Terminal, TerminalMode } from './types/terminal';
+export interface ProcessTerminalOptions {
+    capabilities?: PartialCapabilities;
+    alternateScreen?: boolean;
+    bracketedPaste?: boolean;
+    focusEvents?: boolean;
+    keyboard?: boolean;
+    mouse?: boolean | {
+        drag?: boolean;
+        motion?: boolean;
+        pixel?: boolean;
+    };
+}
+export declare class ProcessTerminal implements Terminal {
+    private readonly options;
+    private _columns;
+    private _rows;
+    private onData;
+    private onResize;
+    private cleanupHandlers;
+    private stdinDataHandler;
+    private stdoutResizeHandler;
+    private started;
+    private readonly enabledModes;
+    readonly capabilities: Capabilities;
+    constructor(options?: ProcessTerminalOptions);
+    get columns(): number;
+    get rows(): number;
+    write(data: string): void;
+    hideCursor(): void;
+    showCursor(): void;
+    clearScreen(): void;
+    clearLine(): void;
+    clearFromCursor(): void;
+    moveBy(lines: number): void;
+    enableMode(mode: TerminalMode): void;
+    disableMode(mode: TerminalMode): void;
+    enableMouse(): void;
+    disableMouse(): void;
+    start(onInput: (data: string) => void, onResize: () => void): void;
+    stop(): void;
+    private applyStartupModes;
+    private restoreModes;
+    private restoreInputAfterDrain;
+    private stopNow;
+    private restoreInputNow;
+}