mu-harness 0.16.3

package/esm/tui/src/terminal.js

@@ -0,0 +1,255 @@
+import process from 'node:process';
+import { createDefaultCapabilities, mergeCapabilities, } from './capabilities';
+async function drainStdin(opts) {
+    const maxMs = opts?.maxMs ?? 200;
+    const idleMs = opts?.idleMs ?? 30;
+    let lastDataTime = Date.now();
+    const onData = () => {
+        lastDataTime = Date.now();
+    };
+    process.stdin.on('data', onData);
+    const endTime = Date.now() + maxMs;
+    try {
+        while (true) {
+            const now = Date.now();
+            if (now - endTime >= 0)
+                break;
+            if (now - lastDataTime >= idleMs)
+                break;
+            await new Promise((resolve) => setTimeout(resolve, Math.min(idleMs, endTime - now)));
+        }
+    }
+    finally {
+        process.stdin.removeListener('data', onData);
+    }
+}
+const MODE_ENABLE = {
+    alternateScreen: '\x1b[?1049h',
+    bracketedPaste: '\x1b[?2004h',
+    focusEvents: '\x1b[?1004h',
+    sgrMouse: '\x1b[?1006h',
+    mouseDrag: '\x1b[?1002h',
+    mouseMotion: '\x1b[?1003h',
+    pixelMouse: '\x1b[?1016h',
+    synchronizedOutput: '\x1b[?2026h',
+    kittyKeyboard: '\x1b[>1u',
+    modifyOtherKeys: '\x1b[>4;2m',
+};
+const MODE_DISABLE = {
+    alternateScreen: '\x1b[?1049l',
+    bracketedPaste: '\x1b[?2004l',
+    focusEvents: '\x1b[?1004l',
+    sgrMouse: '\x1b[?1006l',
+    mouseDrag: '\x1b[?1002l',
+    mouseMotion: '\x1b[?1003l',
+    pixelMouse: '\x1b[?1016l',
+    synchronizedOutput: '\x1b[?2026l',
+    kittyKeyboard: '\x1b[<u',
+    modifyOtherKeys: '\x1b[>4;0m',
+};
+export class ProcessTerminal {
+    options;
+    _columns;
+    _rows;
+    onData = null;
+    onResize = null;
+    cleanupHandlers = [];
+    stdinDataHandler = null;
+    stdoutResizeHandler = null;
+    started = false;
+    enabledModes = [];
+    capabilities;
+    constructor(options = {}) {
+        this.options = options;
+        this._columns = process.stdout.columns || 80;
+        this._rows = process.stdout.rows || 24;
+        this.capabilities = mergeCapabilities(createDefaultCapabilities(), options.capabilities);
+    }
+    get columns() {
+        return this._columns;
+    }
+    get rows() {
+        return this._rows;
+    }
+    write(data) {
+        if (process.stdout.isTTY) {
+            process.stdout.write(data);
+        }
+    }
+    hideCursor() {
+        this.write('\x1b[?25l');
+    }
+    showCursor() {
+        this.write('\x1b[?25h');
+    }
+    clearScreen() {
+        this.write('\x1b[2J\x1b[H');
+    }
+    clearLine() {
+        this.write('\x1b[2K');
+    }
+    clearFromCursor() {
+        this.write('\x1b[0J');
+    }
+    moveBy(lines) {
+        if (lines > 0) {
+            this.write(`\x1b[${lines}B`);
+        }
+        else if (lines < 0) {
+            this.write(`\x1b[${-lines}A`);
+        }
+    }
+    enableMode(mode) {
+        if (!process.stdout.isTTY || this.enabledModes.includes(mode))
+            return;
+        this.write(MODE_ENABLE[mode]);
+        this.enabledModes.push(mode);
+    }
+    disableMode(mode) {
+        const index = this.enabledModes.lastIndexOf(mode);
+        if (index === -1)
+            return;
+        this.write(MODE_DISABLE[mode]);
+        this.enabledModes.splice(index, 1);
+    }
+    enableMouse() {
+        this.enableMode('sgrMouse');
+        this.enableMode('mouseDrag');
+    }
+    disableMouse() {
+        this.disableMode('pixelMouse');
+        this.disableMode('mouseMotion');
+        this.disableMode('mouseDrag');
+        this.disableMode('sgrMouse');
+    }
+    start(onInput, onResize) {
+        if (this.started || !(process.stdin.isTTY && process.stdout.isTTY)) {
+            return;
+        }
+        this.started = true;
+        this.onData = onInput;
+        this.onResize = onResize;
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
+        this.stdinDataHandler = (chunk) => {
+            this.onData?.(chunk);
+        };
+        process.stdin.on('data', this.stdinDataHandler);
+        this.stdoutResizeHandler = () => {
+            this._columns = process.stdout.columns || 80;
+            this._rows = process.stdout.rows || 24;
+            this.onResize?.();
+        };
+        process.stdout.on('resize', this.stdoutResizeHandler);
+        this._columns = process.stdout.columns || 80;
+        this._rows = process.stdout.rows || 24;
+        const handleSigInt = () => {
+            this.stop();
+            if (process.pid)
+                process.kill(process.pid, 'SIGINT');
+        };
+        process.once('SIGINT', handleSigInt);
+        this.cleanupHandlers.push(() => process.removeListener('SIGINT', handleSigInt));
+        const handleSigTerm = () => {
+            this.stop();
+            if (process.pid)
+                process.kill(process.pid, 'SIGTERM');
+        };
+        process.once('SIGTERM', handleSigTerm);
+        this.cleanupHandlers.push(() => process.removeListener('SIGTERM', handleSigTerm));
+        const handleSigHup = () => {
+            this.stop();
+            if (process.pid)
+                process.kill(process.pid, 'SIGHUP');
+        };
+        process.once('SIGHUP', handleSigHup);
+        this.cleanupHandlers.push(() => process.removeListener('SIGHUP', handleSigHup));
+        const handleExit = () => {
+            this.stopNow();
+        };
+        process.once('exit', handleExit);
+        this.cleanupHandlers.push(() => process.removeListener('exit', handleExit));
+        this.applyStartupModes();
+        this.hideCursor();
+    }
+    stop() {
+        if (!this.started)
+            return;
+        this.started = false;
+        this.write('\x1b[?2026l');
+        this.restoreModes();
+        this.write('\x1b[0m\x1b]8;;\x07');
+        this.showCursor();
+        if (this.stdinDataHandler) {
+            process.stdin.removeListener('data', this.stdinDataHandler);
+            this.stdinDataHandler = null;
+        }
+        if (this.stdoutResizeHandler) {
+            process.stdout.removeListener('resize', this.stdoutResizeHandler);
+            this.stdoutResizeHandler = null;
+        }
+        void this.restoreInputAfterDrain();
+        this.onData = null;
+        this.onResize = null;
+        for (const cleanup of this.cleanupHandlers) {
+            try {
+                cleanup();
+            }
+            catch {
+            }
+        }
+        this.cleanupHandlers.length = 0;
+    }
+    applyStartupModes() {
+        if (this.options.alternateScreen)
+            this.enableMode('alternateScreen');
+        if (this.options.bracketedPaste)
+            this.enableMode('bracketedPaste');
+        if (this.options.focusEvents)
+            this.enableMode('focusEvents');
+        if (this.options.keyboard) {
+            this.enableMode('kittyKeyboard');
+            this.enableMode('modifyOtherKeys');
+        }
+        if (this.options.mouse) {
+            this.enableMode('sgrMouse');
+            if (this.options.mouse === true || this.options.mouse.drag)
+                this.enableMode('mouseDrag');
+            if (this.options.mouse !== true && this.options.mouse.motion)
+                this.enableMode('mouseMotion');
+            if (this.options.mouse !== true && this.options.mouse.pixel)
+                this.enableMode('pixelMouse');
+        }
+    }
+    restoreModes() {
+        for (let i = this.enabledModes.length - 1; i >= 0; i--) {
+            this.write(MODE_DISABLE[this.enabledModes[i]]);
+        }
+        this.enabledModes.length = 0;
+    }
+    async restoreInputAfterDrain() {
+        try {
+            await drainStdin();
+        }
+        catch {
+        }
+        finally {
+            this.restoreInputNow();
+        }
+    }
+    stopNow() {
+        if (!this.started)
+            return;
+        this.started = false;
+        this.write('\x1b[?2026l');
+        this.restoreModes();
+        this.write('\x1b[0m\x1b]8;;\x07');
+        this.showCursor();
+        this.restoreInputNow();
+    }
+    restoreInputNow() {
+        process.stdin.pause();
+        process.stdin.setRawMode(false);
+    }
+}

package/esm/tui/src/tui.d.ts

@@ -0,0 +1,60 @@
+import type { InputEvent } from './events';
+import type { GlobalKeybinding } from './keybinds';
+import type { Color } from './layout/types';
+import { type Command } from './components/command-palette';
+import type { Component } from './surface';
+import type { Terminal } from './types/terminal';
+import { type ModalOptions, type ToastKind } from './views';
+export interface TuiOptions {
+    synchronizedOutput?: boolean;
+}
+export interface LayerHandle {
+    close(): void;
+}
+export interface ToastHandle {
+    dismiss(): void;
+}
+export declare class TUI {
+    private readonly terminal;
+    private root;
+    private focused;
+    private entries;
+    private backdrop;
+    private layers;
+    private toasts;
+    private escapeUnsub;
+    private started;
+    private terminalFocused;
+    private readonly renderer;
+    private readonly inputRouter;
+    constructor(terminal: Terminal, options?: TuiOptions);
+    setRoot(component: Component | null): void;
+    setBackgroundColor(color: Color): void;
+    setFocus(component: Component | null): void;
+    getFocused(): Component | null;
+    pushLayer(layer: Component, opts?: {
+        focus?: Component;
+        onClose?: () => void;
+    }): LayerHandle;
+    showModal(content: Component, opts?: ModalOptions & {
+        onClose?: () => void;
+    }): LayerHandle;
+    showCommandPalette(commands: Command[]): LayerHandle;
+    toast(message: string, opts?: {
+        duration?: number;
+        kind?: ToastKind;
+    }): ToastHandle;
+    private dismissToast;
+    private popTopLayer;
+    private removeLayer;
+    private composedRoot;
+    navigateFocus(direction: 'next' | 'previous'): Component | null;
+    addGlobalKeybinding(binding: GlobalKeybinding): () => void;
+    addInputInterceptor(listener: (event: InputEvent) => boolean | undefined): () => void;
+    requestRender(force?: boolean): void;
+    renderNow(): void;
+    componentAt(x: number, y: number): Component | null;
+    start(): void;
+    stop(): void;
+    private handleResize;
+}

package/esm/tui/src/tui.js

@@ -0,0 +1,194 @@
+import { InputRouter } from './inputRouter';
+import { colorToRgba, OPAQUE_BLACK } from './layout/color';
+import { containsPoint } from './layout/insets';
+import { commandPalette } from './components/command-palette';
+import { Renderer } from './renderer';
+import { modal, toast as toastView } from './views';
+export class TUI {
+    terminal;
+    root = null;
+    focused = null;
+    entries = [];
+    backdrop = OPAQUE_BLACK;
+    layers = [];
+    toasts = [];
+    escapeUnsub;
+    started = false;
+    terminalFocused = true;
+    renderer;
+    inputRouter;
+    constructor(terminal, options = {}) {
+        this.terminal = terminal;
+        this.renderer = new Renderer(terminal, {
+            getRoot: () => this.composedRoot(),
+            isFocused: (component) => component === this.focused && this.terminalFocused,
+            setEntries: (entries) => {
+                this.entries = entries;
+            },
+            getBackdropColor: () => this.backdrop,
+        }, options.synchronizedOutput ?? true);
+        this.inputRouter = new InputRouter({
+            getFocused: () => this.focused,
+            getEntries: () => this.entries,
+            getTerminalFocused: () => this.terminalFocused,
+            setTerminalFocused: (focused) => {
+                this.terminalFocused = focused;
+            },
+            requestRender: (force) => this.requestRender(force),
+        });
+    }
+    setRoot(component) {
+        this.root = component;
+        this.requestRender(true);
+    }
+    setBackgroundColor(color) {
+        this.backdrop = { ...colorToRgba(color), a: 1 };
+        this.requestRender(true);
+    }
+    setFocus(component) {
+        this.focused = component;
+        this.requestRender();
+    }
+    getFocused() {
+        return this.focused;
+    }
+    pushLayer(layer, opts = {}) {
+        const entry = { layer, prevFocus: this.focused, onClose: opts.onClose };
+        this.layers.push(entry);
+        if (opts.focus)
+            this.focused = opts.focus;
+        if (!this.escapeUnsub) {
+            this.escapeUnsub = this.addGlobalKeybinding({ chord: { key: 'escape' }, handler: () => this.popTopLayer() });
+        }
+        this.requestRender(true);
+        return { close: () => this.removeLayer(entry) };
+    }
+    showModal(content, opts = {}) {
+        return this.pushLayer(modal(content, opts), { focus: content, onClose: opts.onClose });
+    }
+    showCommandPalette(commands) {
+        const ref = {};
+        const palette = commandPalette(commands, {
+            onRun: (command) => {
+                ref.handle?.close();
+                command.run();
+            },
+        });
+        ref.handle = this.pushLayer(palette, { focus: palette });
+        return ref.handle;
+    }
+    toast(message, opts = {}) {
+        const entry = { view: toastView(message, { kind: opts.kind }) };
+        this.toasts.push(entry);
+        this.requestRender();
+        const timer = setTimeout(() => this.dismissToast(entry), opts.duration ?? 3000);
+        return {
+            dismiss: () => {
+                clearTimeout(timer);
+                this.dismissToast(entry);
+            },
+        };
+    }
+    dismissToast(entry) {
+        const index = this.toasts.indexOf(entry);
+        if (index === -1)
+            return;
+        this.toasts.splice(index, 1);
+        this.requestRender();
+    }
+    popTopLayer() {
+        const top = this.layers[this.layers.length - 1];
+        if (top)
+            this.removeLayer(top);
+    }
+    removeLayer(entry) {
+        const index = this.layers.indexOf(entry);
+        if (index === -1)
+            return;
+        this.layers.splice(index, 1);
+        this.focused = entry.prevFocus;
+        if (this.layers.length === 0 && this.escapeUnsub) {
+            this.escapeUnsub();
+            this.escapeUnsub = undefined;
+        }
+        entry.onClose?.();
+        this.requestRender(true);
+    }
+    composedRoot() {
+        if (this.layers.length === 0 && this.toasts.length === 0)
+            return this.root;
+        const root = this.root;
+        const layers = this.layers;
+        const toasts = this.toasts;
+        return {
+            render: (s) => {
+                const full = { x: 0, y: 0, width: s.width, height: s.height };
+                if (root)
+                    s.child(root, full);
+                for (const entry of layers)
+                    s.child(entry.layer, full);
+                let y = 0;
+                for (const entry of toasts) {
+                    const w = Math.min(40, s.width);
+                    const h = s.measure(entry.view, w);
+                    if (y + h > s.height)
+                        break;
+                    s.child(entry.view, { x: s.width - w, y, width: w, height: h });
+                    y += h + 1;
+                }
+            },
+        };
+    }
+    navigateFocus(direction) {
+        const focusables = this.entries.filter((entry) => entry.component.handleInput).map((entry) => entry.component);
+        if (focusables.length === 0)
+            return null;
+        const current = this.focused ? focusables.indexOf(this.focused) : -1;
+        const forward = direction === 'next';
+        const next = forward ? (current + 1) % focusables.length : (current - 1 + focusables.length) % focusables.length;
+        this.setFocus(focusables[next]);
+        return focusables[next];
+    }
+    addGlobalKeybinding(binding) {
+        return this.inputRouter.addGlobalKeybinding(binding);
+    }
+    addInputInterceptor(listener) {
+        return this.inputRouter.addInputInterceptor(listener);
+    }
+    requestRender(force = false) {
+        this.renderer.requestRender(force);
+    }
+    renderNow() {
+        this.renderer.doRender();
+    }
+    componentAt(x, y) {
+        for (let i = this.entries.length - 1; i >= 0; i--) {
+            if (containsPoint(this.entries[i].rect, x, y))
+                return this.entries[i].component;
+        }
+        return null;
+    }
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.renderer.setStopped(false);
+        this.inputRouter.setStopped(false);
+        this.terminal.start?.((data) => this.inputRouter.feed(data), () => this.handleResize());
+        this.terminal.hideCursor();
+        this.requestRender(true);
+    }
+    stop() {
+        if (!this.started)
+            return;
+        this.started = false;
+        this.renderer.setStopped(true);
+        this.inputRouter.setStopped(true);
+        this.renderer.moveCursorAfterRenderedContent();
+        this.terminal.stop?.();
+        this.terminal.showCursor();
+    }
+    handleResize() {
+        this.requestRender(true);
+    }
+}

package/esm/tui/src/types/terminal.d.ts

@@ -0,0 +1,20 @@
+import type { Capabilities } from '../capabilities';
+export type TerminalMode = 'alternateScreen' | 'bracketedPaste' | 'focusEvents' | 'sgrMouse' | 'mouseDrag' | 'mouseMotion' | 'pixelMouse' | 'synchronizedOutput' | 'kittyKeyboard' | 'modifyOtherKeys';
+export interface Terminal {
+    readonly columns: number;
+    readonly 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;
+    readonly capabilities?: Capabilities;
+}

package/esm/tui/src/types/terminal.js

@@ -0,0 +1 @@
+export {};

package/esm/tui/src/utils.d.ts

@@ -0,0 +1,6 @@
+export declare function stripAnsi(s: string): string;
+export declare function visibleWidth(s: string): number;
+export declare function charWidth(code: number): number;
+export declare function truncateToWidth(s: string, width: number, ellipsis?: string): string;
+export declare function wrapText(text: string, width: number): string[];
+export declare function sliceByColumn(s: string, start: number, end: number, strict?: boolean): string;