mu-harness 0.16.3

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

@@ -0,0 +1,56 @@
+export interface Modifiers {
+    shift: boolean;
+    ctrl: boolean;
+    alt: boolean;
+    meta: boolean;
+}
+export type KeyEventKind = 'press' | 'repeat' | 'release';
+export interface KeyInputEvent extends Modifiers {
+    type: 'key';
+    key: string;
+    kind: KeyEventKind;
+    text?: string;
+    source: 'legacy' | 'xterm' | 'csi-u' | 'kitty' | 'unknown';
+    raw: string;
+}
+export interface TextInputEvent {
+    type: 'text';
+    text: string;
+    raw: string;
+}
+export type MouseButton = 'left' | 'middle' | 'right' | 'wheelUp' | 'wheelDown' | 'wheelLeft' | 'wheelRight' | 'unknown';
+export type MouseEventKind = 'press' | 'release' | 'drag' | 'move' | 'wheel';
+export interface MouseInputEvent extends Modifiers {
+    type: 'mouse';
+    kind: MouseEventKind;
+    button: MouseButton;
+    x: number;
+    y: number;
+    localX?: number;
+    localY?: number;
+    coordinateSpace: 'cells' | 'pixels';
+    source: 'sgr' | 'x10' | 'urxvt' | 'pixel' | 'unknown';
+    raw: string;
+}
+export interface PasteInputEvent {
+    type: 'paste';
+    text: string;
+    raw: string;
+}
+export interface FocusInputEvent {
+    type: 'focus';
+    focused: boolean;
+    raw: string;
+}
+export interface ResizeInputEvent {
+    type: 'resize';
+    columns: number;
+    rows: number;
+}
+export interface TerminalResponseEvent {
+    type: 'terminalResponse';
+    raw: string;
+    sequence: 'csi' | 'osc' | 'dcs' | 'apc' | 'pm' | 'sos' | 'escape' | 'unknown';
+}
+export type InputEvent = KeyInputEvent | TextInputEvent | MouseInputEvent | PasteInputEvent | FocusInputEvent | ResizeInputEvent | TerminalResponseEvent;
+export declare const NO_MODIFIERS: Modifiers;

package/esm/tui/src/events.js

@@ -0,0 +1,6 @@
+export const NO_MODIFIERS = {
+    shift: false,
+    ctrl: false,
+    alt: false,
+    meta: false,
+};

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

@@ -0,0 +1,17 @@
+export type { Component, Surface, SurfaceEntry } from './surface';
+export { measure, measureWidth, renderToBuffer } from './surface';
+export { box, type BoxOptions, column, flex, type FlexItem, modal, type ModalOptions, overlay, type OverlayOptions, row, text, toast, type ToastKind, type ToastOptions, } from './views';
+export { Editor, editor, type EditorOptions } from './components/editor';
+export { ScrollView, scrollView } from './components/scroll-view';
+export { type SelectItem, SelectList, selectList } from './components/select-list';
+export { type Command, CommandPalette, commandPalette, type CommandPaletteOptions } from './components/command-palette';
+export { type LayerHandle, type ToastHandle, TUI, type TuiOptions } from './tui';
+export { ProcessTerminal, type ProcessTerminalOptions } from './terminal';
+export type { Terminal, TerminalMode } from './types/terminal';
+export type { InputEvent, KeyInputEvent, Modifiers, MouseInputEvent } from './events';
+export { parseInput } from './keyboard';
+export { TerminalInputParser } from './parser';
+export { type GlobalKeybinding, type KeyChord, keyMatches } from './keybinds';
+export { type Capabilities, capability, type CapabilitySource, createDefaultCapabilities, mergeCapabilities, type PartialCapabilities, } from './capabilities';
+export { truncateToWidth, visibleWidth, wrapText } from './utils';
+export type { Color, Rect } from './layout/types';

package/esm/tui/src/index.js

@@ -0,0 +1,13 @@
+export { measure, measureWidth, renderToBuffer } from './surface';
+export { box, column, flex, modal, overlay, row, text, toast, } from './views';
+export { Editor, editor } from './components/editor';
+export { ScrollView, scrollView } from './components/scroll-view';
+export { SelectList, selectList } from './components/select-list';
+export { CommandPalette, commandPalette } from './components/command-palette';
+export { TUI } from './tui';
+export { ProcessTerminal } from './terminal';
+export { parseInput } from './keyboard';
+export { TerminalInputParser } from './parser';
+export { keyMatches } from './keybinds';
+export { capability, createDefaultCapabilities, mergeCapabilities, } from './capabilities';
+export { truncateToWidth, visibleWidth, wrapText } from './utils';

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

@@ -0,0 +1,28 @@
+import type { InputEvent } from './events';
+import type { GlobalKeybinding } from './keybinds';
+import type { Component, SurfaceEntry } from './surface';
+export interface InputRouterHost {
+    getFocused(): Component | null;
+    getEntries(): SurfaceEntry[];
+    setTerminalFocused(focused: boolean): void;
+    getTerminalFocused(): boolean;
+    requestRender(force?: boolean): void;
+}
+export declare class InputRouter {
+    private readonly host;
+    private readonly parser;
+    private readonly inputInterceptors;
+    private readonly globalKeybindings;
+    private pendingEscapeTimer;
+    private readonly escapeTimeoutMs;
+    private stopped;
+    constructor(host: InputRouterHost);
+    setStopped(stopped: boolean): void;
+    addInputInterceptor(listener: (event: InputEvent) => boolean | undefined): () => void;
+    addGlobalKeybinding(binding: GlobalKeybinding): () => void;
+    feed(data: string): void;
+    private dispatchEvents;
+    dispatchEvent(event: InputEvent): void;
+    private handleMouseEvent;
+    private handleGlobalKeybinding;
+}

package/esm/tui/src/inputRouter.js

@@ -0,0 +1,122 @@
+import { keyMatches } from './keybinds';
+import { containsPoint } from './layout/insets';
+import { TerminalInputParser } from './parser';
+export class InputRouter {
+    host;
+    parser;
+    inputInterceptors = [];
+    globalKeybindings = [];
+    pendingEscapeTimer;
+    escapeTimeoutMs = 25;
+    stopped = false;
+    constructor(host) {
+        this.host = host;
+        this.parser = new TerminalInputParser();
+    }
+    setStopped(stopped) {
+        this.stopped = stopped;
+        if (stopped && this.pendingEscapeTimer) {
+            clearTimeout(this.pendingEscapeTimer);
+            this.pendingEscapeTimer = undefined;
+        }
+    }
+    addInputInterceptor(listener) {
+        this.inputInterceptors.push(listener);
+        return () => {
+            const index = this.inputInterceptors.indexOf(listener);
+            if (index !== -1)
+                this.inputInterceptors.splice(index, 1);
+        };
+    }
+    addGlobalKeybinding(binding) {
+        this.globalKeybindings.push(binding);
+        return () => {
+            const index = this.globalKeybindings.indexOf(binding);
+            if (index !== -1)
+                this.globalKeybindings.splice(index, 1);
+        };
+    }
+    feed(data) {
+        this.dispatchEvents(this.parser.feed(data));
+        if (this.parser.hasPending()) {
+            if (!this.pendingEscapeTimer) {
+                this.pendingEscapeTimer = setTimeout(() => {
+                    this.pendingEscapeTimer = undefined;
+                    this.dispatchEvents(this.parser.flushPending());
+                }, this.escapeTimeoutMs);
+            }
+        }
+        else if (this.pendingEscapeTimer) {
+            clearTimeout(this.pendingEscapeTimer);
+            this.pendingEscapeTimer = undefined;
+        }
+    }
+    dispatchEvents(events) {
+        for (const event of events)
+            this.dispatchEvent(event);
+    }
+    dispatchEvent(event) {
+        for (const interceptor of this.inputInterceptors.slice()) {
+            try {
+                if (interceptor(event)) {
+                    this.host.requestRender();
+                    return;
+                }
+            }
+            catch {
+                // a faulty interceptor must not break input
+            }
+        }
+        if (event.type === 'mouse') {
+            this.handleMouseEvent(event);
+            return;
+        }
+        if (event.type === 'focus') {
+            if (this.host.getTerminalFocused() !== event.focused) {
+                this.host.setTerminalFocused(event.focused);
+                this.host.requestRender();
+            }
+            return;
+        }
+        if (event.type === 'key' && this.handleGlobalKeybinding(event))
+            return;
+        const focused = this.host.getFocused();
+        if (event.type === 'key' && event.kind === 'release' && !focused?.wantsKeyRelease)
+            return;
+        if (focused?.handleInput) {
+            focused.handleInput(event);
+            this.host.requestRender();
+        }
+    }
+    handleMouseEvent(event) {
+        if (this.stopped)
+            return;
+        const entries = this.host.getEntries();
+        for (let i = entries.length - 1; i >= 0; i--) {
+            const entry = entries[i];
+            if (!entry.component.handleInput)
+                continue;
+            if (!containsPoint(entry.rect, event.x, event.y))
+                continue;
+            entry.component.handleInput({ ...event, localX: event.x - entry.rect.x, localY: event.y - entry.rect.y });
+            this.host.requestRender();
+            return;
+        }
+        const focused = this.host.getFocused();
+        if (focused?.handleInput) {
+            focused.handleInput(event);
+            this.host.requestRender();
+        }
+    }
+    handleGlobalKeybinding(event) {
+        if (event.type !== 'key')
+            return false;
+        for (const binding of this.globalKeybindings) {
+            if (keyMatches(binding.chord, event)) {
+                binding.handler(event);
+                return true;
+            }
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { InputEvent, KeyInputEvent } from './events';
+export interface KeyChord {
+    key?: string;
+    shift?: boolean;
+    ctrl?: boolean;
+    meta?: boolean;
+    alt?: boolean;
+}
+export interface GlobalKeybinding {
+    chord: KeyChord;
+    handler: (event: KeyInputEvent) => void;
+}
+export declare function keyMatches(chord: KeyChord, event: InputEvent): boolean;

package/esm/tui/src/keybinds.js

@@ -0,0 +1,15 @@
+export function keyMatches(chord, event) {
+    if (event.type !== 'key')
+        return false;
+    if (chord.key !== undefined && chord.key !== event.key)
+        return false;
+    if ((chord.shift ?? false) !== event.shift)
+        return false;
+    if ((chord.ctrl ?? false) !== event.ctrl)
+        return false;
+    if ((chord.meta ?? false) !== event.meta)
+        return false;
+    if ((chord.alt ?? false) !== event.alt)
+        return false;
+    return true;
+}

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

@@ -0,0 +1,2 @@
+import { type InputEvent } from './events';
+export declare function parseInput(raw: string): InputEvent | null;

package/esm/tui/src/keyboard.js

@@ -0,0 +1,305 @@
+import { NO_MODIFIERS } from './events';
+// deno-lint-ignore no-control-regex
+const CSI_U_RE = /^\x1b\[(\d+)(?::[\d:]+)?(?:;(\d+(?::\d+)?))?(?:;([\d:]+))?u$/;
+// deno-lint-ignore no-control-regex
+const LEGACY_KITTY_RE = /^\x1b\[<(\d+);(\d+)u$/;
+// deno-lint-ignore no-control-regex
+const XTERM_MODIFIED_RE = /^\x1b\[27;(\d+);(\d+)~$/;
+// deno-lint-ignore no-control-regex
+const SGR_MOUSE_RE = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/;
+// deno-lint-ignore no-control-regex
+const CSI_TILDE_RE = /^\x1b\[([0-9;]*)~$/;
+// deno-lint-ignore no-control-regex
+const CSI_KEY_RE = /^\x1b\[([0-9;]*)([A-HIOPR])$/;
+// deno-lint-ignore no-control-regex
+const SS3_RE = /^\x1bO([A-DFHPQS])$/;
+// deno-lint-ignore no-control-regex
+const ALT_PREFIX_RE = /^\x1b(.+)$/;
+// deno-lint-ignore no-control-regex
+const CTRL_RE = /^[\x01-\x1a]$/;
+const CSI_KEY_MAP = {
+    A: 'up',
+    B: 'down',
+    C: 'right',
+    D: 'left',
+    H: 'home',
+    F: 'end',
+    P: 'f1',
+    Q: 'f2',
+    R: 'f3',
+    1: 'home',
+    2: 'insert',
+    3: 'delete',
+    4: 'end',
+    5: 'pageUp',
+    6: 'pageDown',
+};
+const CSI_NUM_KEY_MAP = {
+    11: 'f1',
+    12: 'f2',
+    13: 'f3',
+    14: 'f4',
+    15: 'f5',
+    17: 'f6',
+    18: 'f7',
+    19: 'f8',
+    20: 'f9',
+    21: 'f10',
+    23: 'f11',
+    24: 'f12',
+};
+const SS3_KEY_MAP = {
+    A: 'up',
+    B: 'down',
+    C: 'right',
+    D: 'left',
+    H: 'home',
+    F: 'end',
+    P: 'f1',
+    Q: 'f2',
+    R: 'f3',
+    S: 'f4',
+};
+export function parseInput(raw) {
+    if (raw.length === 0)
+        return null;
+    if (raw === '\r' || raw === '\n') {
+        return key('enter', { raw, source: 'legacy' });
+    }
+    if (raw === '\x1b') {
+        return key('escape', { raw, source: 'legacy' });
+    }
+    if (raw === '\t') {
+        return key('tab', { raw, source: 'legacy' });
+    }
+    if (raw === '\x7f' || raw === '\b') {
+        return key('backspace', { raw, source: 'legacy' });
+    }
+    if (CTRL_RE.test(raw)) {
+        const code = raw.charCodeAt(0);
+        if (code === 9 || code === 10 || code === 13)
+            return null;
+        return key(String.fromCharCode(code + 96), { raw, source: 'legacy', ctrl: true });
+    }
+    const mouseMatch = raw.match(SGR_MOUSE_RE);
+    if (mouseMatch) {
+        return parseSgrMouse(raw, mouseMatch);
+    }
+    if (raw === '\x1b[I') {
+        return { type: 'focus', focused: true, raw };
+    }
+    if (raw === '\x1b[O') {
+        return { type: 'focus', focused: false, raw };
+    }
+    const csiUMatch = raw.match(CSI_U_RE);
+    if (csiUMatch) {
+        const code = Number.parseInt(csiUMatch[1], 10);
+        const encodedModifiers = csiUMatch[2] ? Number.parseInt(csiUMatch[2], 10) : 1;
+        const modifiers = decodeEncodedModifiers(encodedModifiers);
+        const eventType = decodeKittyEventType(csiUMatch[2]);
+        return key(codepointToKey(code), {
+            ...modifiers,
+            kind: eventType,
+            raw,
+            source: 'csi-u',
+            text: codepointToText(code),
+        });
+    }
+    const legacyKittyMatch = raw.match(LEGACY_KITTY_RE);
+    if (legacyKittyMatch) {
+        const code = Number.parseInt(legacyKittyMatch[1], 10);
+        const modifiers = decodeEncodedModifiers(Number.parseInt(legacyKittyMatch[2], 10));
+        return key(codepointToKey(code), { ...modifiers, raw, source: 'kitty', text: codepointToText(code) });
+    }
+    const xtermMatch = raw.match(XTERM_MODIFIED_RE);
+    if (xtermMatch) {
+        const first = Number.parseInt(xtermMatch[1], 10);
+        const second = Number.parseInt(xtermMatch[2], 10);
+        const modifierParam = first <= 8 && second > 8 ? first : second;
+        const code = first <= 8 && second > 8 ? second : first;
+        const modifiers = decodeEncodedModifiers(modifierParam);
+        return key(codepointToKey(code), { ...modifiers, raw, source: 'xterm', text: codepointToText(code) });
+    }
+    const csiTildeMatch = raw.match(CSI_TILDE_RE);
+    if (csiTildeMatch) {
+        const params = splitParams(csiTildeMatch[1]);
+        const keyName = params.length > 0 ? (CSI_NUM_KEY_MAP[params[0]] ?? CSI_KEY_MAP[params[0]]) : undefined;
+        if (keyName) {
+            return key(keyName, { ...decodeOptionalModifier(params[1]), raw, source: 'xterm' });
+        }
+    }
+    const csiMatch = raw.match(CSI_KEY_RE);
+    if (csiMatch) {
+        const params = splitParams(csiMatch[1]);
+        const final = csiMatch[2];
+        const keyName = CSI_KEY_MAP[final] ?? (params.length > 0 ? CSI_KEY_MAP[params[0]] : undefined);
+        if (keyName) {
+            return key(keyName, { ...decodeOptionalModifier(params[1]), raw, source: 'xterm' });
+        }
+    }
+    const ss3Match = raw.match(SS3_RE);
+    if (ss3Match) {
+        return key(SS3_KEY_MAP[ss3Match[1]] ?? ss3Match[1], { raw, source: 'legacy' });
+    }
+    if (isControlSequence(raw)) {
+        return { type: 'terminalResponse', raw, sequence: classifySequence(raw) };
+    }
+    const altMatch = raw.match(ALT_PREFIX_RE);
+    if (altMatch) {
+        const inner = parseInput(altMatch[1]);
+        if (inner?.type === 'key') {
+            return { ...inner, alt: true, meta: true, raw };
+        }
+        if (inner?.type === 'text') {
+            return key(inner.text, { raw, source: 'legacy', alt: true, meta: true, text: inner.text });
+        }
+    }
+    const chars = Array.from(raw);
+    if (chars.length === 1) {
+        return key(chars[0], { raw, source: 'legacy', text: chars[0] });
+    }
+    if (!raw.includes('\x1b')) {
+        return { type: 'text', text: raw, raw };
+    }
+    return { type: 'terminalResponse', raw, sequence: classifySequence(raw) };
+}
+function key(name, opts) {
+    return {
+        type: 'key',
+        key: name,
+        kind: opts.kind ?? 'press',
+        shift: opts.shift ?? false,
+        ctrl: opts.ctrl ?? false,
+        alt: opts.alt ?? false,
+        meta: opts.meta ?? false,
+        source: opts.source,
+        raw: opts.raw,
+        ...(opts.text ? { text: opts.text } : {}),
+    };
+}
+function parseSgrMouse(raw, match) {
+    const cb = Number.parseInt(match[1], 10);
+    const x = Number.parseInt(match[2], 10) - 1;
+    const y = Number.parseInt(match[3], 10) - 1;
+    const final = match[4];
+    const modifiers = decodeMouseModifiers(cb);
+    const code = cb & ~(4 | 8 | 16);
+    const isRelease = final === 'm' || (code & 3) === 3;
+    const isWheel = code >= 64 && code <= 67;
+    const buttonCode = code & 3;
+    const isMove = (code & 32) !== 0 && buttonCode === 3;
+    const isDrag = (code & 32) !== 0 && buttonCode < 3;
+    return {
+        type: 'mouse',
+        kind: isWheel ? 'wheel' : isDrag ? 'drag' : isMove ? 'move' : isRelease ? 'release' : 'press',
+        button: mouseButton(code, buttonCode),
+        x,
+        y,
+        coordinateSpace: 'cells',
+        source: 'sgr',
+        raw,
+        ...modifiers,
+    };
+}
+function mouseButton(code, buttonCode) {
+    if (code === 64)
+        return 'wheelUp';
+    if (code === 65)
+        return 'wheelDown';
+    if (code === 66)
+        return 'wheelLeft';
+    if (code === 67)
+        return 'wheelRight';
+    if (buttonCode === 0)
+        return 'left';
+    if (buttonCode === 1)
+        return 'middle';
+    if (buttonCode === 2)
+        return 'right';
+    return 'unknown';
+}
+function decodeMouseModifiers(cb) {
+    return {
+        shift: (cb & 4) !== 0,
+        alt: (cb & 8) !== 0,
+        meta: (cb & 8) !== 0,
+        ctrl: (cb & 16) !== 0,
+    };
+}
+function decodeEncodedModifiers(encoded) {
+    const mask = Math.max(0, encoded - 1);
+    return {
+        shift: (mask & 1) !== 0,
+        alt: (mask & 2) !== 0,
+        ctrl: (mask & 4) !== 0,
+        meta: (mask & 8) !== 0 || (mask & 32) !== 0,
+    };
+}
+function decodeOptionalModifier(param) {
+    if (!param)
+        return { ...NO_MODIFIERS };
+    return decodeEncodedModifiers(Number.parseInt(param, 10));
+}
+function splitParams(params) {
+    return params.length === 0 ? [] : params.split(';').filter(Boolean);
+}
+function codepointToKey(code) {
+    const named = {
+        1: 'escape',
+        2: 'insert',
+        3: 'delete',
+        4: 'end',
+        5: 'pageUp',
+        6: 'pageDown',
+        7: 'home',
+        8: 'end',
+        9: 'tab',
+        13: 'enter',
+        27: 'escape',
+        127: 'backspace',
+    };
+    return named[code] ?? codepointToText(code) ?? `unknown:${code}`;
+}
+function codepointToText(code) {
+    if (code < 0x20 || code === 0x7f)
+        return undefined;
+    try {
+        return String.fromCodePoint(code);
+    }
+    catch {
+        return undefined;
+    }
+}
+function decodeKittyEventType(modifierAndType) {
+    const eventType = modifierAndType?.split(':')[1];
+    if (eventType === '2')
+        return 'repeat';
+    if (eventType === '3')
+        return 'release';
+    return 'press';
+}
+function classifySequence(raw) {
+    if (raw.startsWith('\x1b['))
+        return 'csi';
+    if (raw.startsWith('\x1b]'))
+        return 'osc';
+    if (raw.startsWith('\x1bP'))
+        return 'dcs';
+    if (raw.startsWith('\x1b_'))
+        return 'apc';
+    if (raw.startsWith('\x1b^'))
+        return 'pm';
+    if (raw.startsWith('\x1bX'))
+        return 'sos';
+    if (raw.startsWith('\x1b'))
+        return 'escape';
+    return 'unknown';
+}
+function isControlSequence(raw) {
+    return (raw.startsWith('\x1b[') ||
+        raw.startsWith('\x1b]') ||
+        raw.startsWith('\x1bP') ||
+        raw.startsWith('\x1b_') ||
+        raw.startsWith('\x1b^') ||
+        raw.startsWith('\x1bX'));
+}

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

@@ -0,0 +1,3 @@
+import { type Cell } from './cell';
+export declare function parseLine(line: string): Cell[];
+export declare function cellsToAnsi(cells: Cell[]): string;