mu-harness 0.16.3

package/esm/tui/src/parser.js

@@ -0,0 +1,136 @@
+import { parseInput } from './keyboard';
+const ESC = '\x1b';
+const PASTE_START = '\x1b[200~';
+const PASTE_END = '\x1b[201~';
+export 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 = parseInput(token);
+            if (event)
+                events.push(event);
+        }
+        return events;
+    }
+    flushPending() {
+        if (this.buffer.length === 0)
+            return [];
+        const raw = this.buffer;
+        this.buffer = '';
+        const event = 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;
+    }
+}
+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/esm/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/esm/tui/src/renderer.js

@@ -0,0 +1,168 @@
+import { performance } from 'node:perf_hooks';
+import process from 'node:process';
+import { cellsToAnsi } from './layout/ansi';
+import { bufferUsedHeight, cellBufferToLines, createCellBuffer, diffBuffer, setBackdropColor, } from './layout/cellbuffer';
+import { renderToBuffer } from './surface';
+export 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;
+            process.nextTick(() => {
+                if (this.stopped || !this.renderRequested)
+                    return;
+                this.renderRequested = false;
+                this.lastRenderAt = performance.now();
+                this.doRender();
+            });
+            return;
+        }
+        if (this.renderRequested)
+            return;
+        this.renderRequested = true;
+        process.nextTick(() => this.scheduleRender());
+    }
+    scheduleRender() {
+        if (this.stopped || this.renderTimer || !this.renderRequested)
+            return;
+        const elapsed = 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 = performance.now();
+            this.doRender();
+            if (this.renderRequested) {
+                this.scheduleRender();
+            }
+        }, delay);
+    }
+    renderFrame(width, height) {
+        const backdrop = this.host.getBackdropColor();
+        const buffer = createCellBuffer(width, height, backdrop);
+        setBackdropColor(buffer, backdrop);
+        const root = this.host.getRoot();
+        if (root) {
+            this.host.setEntries(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 = 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 = 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 = 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 += 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' : '';
+    }
+}

package/esm/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/esm/tui/src/surface.js

@@ -0,0 +1,110 @@
+import { parseLine } from './layout/ansi';
+import { fillBackground, popOpacity, pushOpacity, writeCells } from './layout/cellbuffer';
+import { colorToRgba } from './layout/color';
+import { intersectRect } from './layout/insets';
+import { visibleWidth } from './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;
+        writeCells(this.env.buffer, this.ox + x, this.oy + y, 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 };
+        fillBackground(this.env.buffer, abs, 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 = 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)
+            pushOpacity(this.env.buffer, opts.opacity);
+        child.render(sub);
+        if (dim)
+            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 = 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);
+    }
+}
+export function measure(component, width) {
+    const probe = new ProbeSurface(Math.max(0, width));
+    component.render(probe);
+    return probe.maxRow;
+}
+export function measureWidth(component, maxWidth) {
+    const probe = new ProbeSurface(Math.max(0, maxWidth));
+    component.render(probe);
+    return probe.maxCol;
+}
+export 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/esm/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;
+}