mu-harness 0.16.3

package/script/tui/src/components/command-palette.d.ts

@@ -0,0 +1,24 @@
+import type { InputEvent } from '../events';
+import type { Component, Surface } from '../surface';
+export interface Command {
+    id: string;
+    label: string;
+    run: () => void;
+}
+export interface CommandPaletteOptions {
+    onRun: (command: Command) => void;
+    placeholder?: string;
+    width?: number;
+}
+export declare class CommandPalette implements Component {
+    private readonly commands;
+    private readonly query;
+    private readonly list;
+    private readonly width;
+    private readonly onRun;
+    constructor(commands: Command[], opts: CommandPaletteOptions);
+    render(s: Surface): void;
+    handleInput(event: InputEvent): void;
+    private refilter;
+}
+export declare const commandPalette: (commands: Command[], opts: CommandPaletteOptions) => CommandPalette;

package/script/tui/src/components/command-palette.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandPalette = exports.CommandPalette = void 0;
+const views_1 = require("../views");
+const editor_1 = require("./editor");
+const select_list_1 = require("./select-list");
+class CommandPalette {
+    commands;
+    query;
+    list;
+    width;
+    onRun;
+    constructor(commands, opts) {
+        this.commands = commands;
+        this.onRun = opts.onRun;
+        this.width = opts.width ?? 60;
+        this.query = (0, editor_1.editor)({ placeholder: opts.placeholder ?? 'Rechercher une commande…' });
+        this.list = (0, select_list_1.selectList)([]);
+        this.refilter();
+    }
+    render(s) {
+        s.fill({ x: 0, y: 0, width: s.width, height: s.height }, '#000000', 0.5);
+        const panel = {
+            render: (ps) => {
+                ps.child(this.query, { x: 0, y: 0, width: ps.width, height: 1 }, { focused: true });
+                const listHeight = ps.measure(this.list, ps.width);
+                ps.child(this.list, { x: 0, y: 1, width: ps.width, height: listHeight });
+            },
+        };
+        const boxed = (0, views_1.box)(panel, { border: true, background: '#1c1c1c' });
+        const w = Math.min(this.width, Math.max(0, s.width - 2));
+        const h = Math.min(s.measure(boxed, w), Math.max(0, s.height - 2));
+        const x = Math.max(0, Math.floor((s.width - w) / 2));
+        const y = Math.max(0, Math.floor((s.height - h) / 3));
+        s.child(boxed, { x, y, width: w, height: h });
+    }
+    handleInput(event) {
+        if (event.type === 'key' && event.kind !== 'release') {
+            if (event.key === 'up') {
+                this.list.move(-1);
+                return;
+            }
+            if (event.key === 'down') {
+                this.list.move(1);
+                return;
+            }
+            if (event.key === 'enter') {
+                const item = this.list.selectedItem();
+                if (item)
+                    this.onRun(item.value);
+                return;
+            }
+        }
+        this.query.handleInput(event);
+        this.refilter();
+    }
+    refilter() {
+        const query = this.query.getValue().toLowerCase();
+        const matched = this.commands.filter((command) => command.label.toLowerCase().includes(query));
+        this.list.setItems(matched.map((command) => ({ label: command.label, value: command })));
+    }
+}
+exports.CommandPalette = CommandPalette;
+const commandPalette = (commands, opts) => new CommandPalette(commands, opts);
+exports.commandPalette = commandPalette;

package/script/tui/src/components/editor.d.ts

@@ -0,0 +1,26 @@
+import type { InputEvent } from '../events';
+import type { Component, Surface } from '../surface';
+export interface EditorOptions {
+    value?: string;
+    placeholder?: string;
+    onSubmit?: (value: string) => void;
+    onChange?: (value: string) => void;
+}
+export declare class Editor implements Component {
+    private value;
+    private cursor;
+    private scroll;
+    private readonly placeholder;
+    onSubmit?: (value: string) => void;
+    onChange?: (value: string) => void;
+    constructor(opts?: EditorOptions);
+    getValue(): string;
+    setValue(value: string): void;
+    render(s: Surface): void;
+    handleInput(event: InputEvent): void;
+    private handleKey;
+    private insert;
+    private backspace;
+    private deleteForward;
+}
+export declare const editor: (opts?: EditorOptions) => Editor;

package/script/tui/src/components/editor.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editor = exports.Editor = void 0;
+const utils_1 = require("../utils");
+const CURSOR = '\x1b[7m';
+const RESET = '\x1b[0m';
+const DIM = '\x1b[2m';
+class Editor {
+    value;
+    cursor;
+    scroll = 0;
+    placeholder;
+    onSubmit;
+    onChange;
+    constructor(opts = {}) {
+        this.value = opts.value ?? '';
+        this.cursor = this.value.length;
+        this.placeholder = opts.placeholder ?? '';
+        this.onSubmit = opts.onSubmit;
+        this.onChange = opts.onChange;
+    }
+    getValue() {
+        return this.value;
+    }
+    setValue(value) {
+        this.value = value;
+        if (this.cursor > value.length)
+            this.cursor = value.length;
+        this.onChange?.(value);
+    }
+    render(s) {
+        const width = s.width;
+        if (width <= 0)
+            return;
+        if (this.value.length === 0 && this.placeholder && !s.focused) {
+            s.text(0, 0, `${DIM}${(0, utils_1.sliceByColumn)(this.placeholder, 0, width, true)}${RESET}`);
+            return;
+        }
+        if (this.cursor < this.scroll)
+            this.scroll = this.cursor;
+        else if (this.cursor >= this.scroll + width)
+            this.scroll = this.cursor - width + 1;
+        const visible = this.value.slice(this.scroll, this.scroll + width);
+        if (!s.focused) {
+            s.text(0, 0, visible);
+            return;
+        }
+        const col = this.cursor - this.scroll;
+        const before = visible.slice(0, col);
+        const at = visible.slice(col, col + 1) || ' ';
+        const after = visible.slice(col + 1);
+        s.text(0, 0, `${before}${CURSOR}${at}${RESET}${after}`);
+    }
+    handleInput(event) {
+        if (event.type === 'paste') {
+            this.insert(event.text.replace(/\n/g, ' '));
+            return;
+        }
+        if (event.type === 'text') {
+            this.insert(event.text);
+            return;
+        }
+        if (event.type !== 'key' || event.kind === 'release')
+            return;
+        this.handleKey(event);
+    }
+    handleKey(event) {
+        switch (event.key) {
+            case 'enter':
+                this.onSubmit?.(this.value);
+                return;
+            case 'backspace':
+                this.backspace();
+                return;
+            case 'delete':
+                this.deleteForward();
+                return;
+            case 'left':
+                this.cursor = Math.max(0, this.cursor - 1);
+                return;
+            case 'right':
+                this.cursor = Math.min(this.value.length, this.cursor + 1);
+                return;
+            case 'home':
+                this.cursor = 0;
+                return;
+            case 'end':
+                this.cursor = this.value.length;
+                return;
+            default:
+                if (event.text && !event.ctrl && !event.meta && !event.alt)
+                    this.insert(event.text);
+        }
+    }
+    insert(text) {
+        this.value = this.value.slice(0, this.cursor) + text + this.value.slice(this.cursor);
+        this.cursor += text.length;
+        this.onChange?.(this.value);
+    }
+    backspace() {
+        if (this.cursor === 0)
+            return;
+        this.value = this.value.slice(0, this.cursor - 1) + this.value.slice(this.cursor);
+        this.cursor -= 1;
+        this.onChange?.(this.value);
+    }
+    deleteForward() {
+        if (this.cursor >= this.value.length)
+            return;
+        this.value = this.value.slice(0, this.cursor) + this.value.slice(this.cursor + 1);
+        this.onChange?.(this.value);
+    }
+}
+exports.Editor = Editor;
+const editor = (opts) => new Editor(opts);
+exports.editor = editor;

package/script/tui/src/components/scroll-view.d.ts

@@ -0,0 +1,14 @@
+import type { InputEvent } from '../events';
+import type { Component, Surface } from '../surface';
+export declare class ScrollView implements Component {
+    private content;
+    private scrollY;
+    private stick;
+    constructor(content: Component);
+    setContent(content: Component): void;
+    scrollToBottom(): void;
+    render(s: Surface): void;
+    handleInput(event: InputEvent): void;
+    private scrollBy;
+}
+export declare const scrollView: (content: Component) => ScrollView;

package/script/tui/src/components/scroll-view.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scrollView = exports.ScrollView = void 0;
+class ScrollView {
+    content;
+    scrollY = 0;
+    stick = true;
+    constructor(content) {
+        this.content = content;
+    }
+    setContent(content) {
+        this.content = content;
+    }
+    scrollToBottom() {
+        this.stick = true;
+    }
+    render(s) {
+        const contentHeight = s.measure(this.content, s.width);
+        if (Number.isFinite(s.height)) {
+            const maxScroll = Math.max(0, contentHeight - s.height);
+            if (!this.stick && this.scrollY >= maxScroll)
+                this.stick = true;
+            this.scrollY = this.stick ? maxScroll : Math.min(this.scrollY, maxScroll);
+        }
+        const scroll = Number.isFinite(s.height) ? this.scrollY : 0;
+        s.child(this.content, { x: 0, y: -scroll, width: s.width, height: contentHeight });
+    }
+    handleInput(event) {
+        if (event.type === 'mouse' && event.kind === 'wheel') {
+            if (event.button === 'wheelUp')
+                this.scrollBy(-1);
+            else if (event.button === 'wheelDown')
+                this.scrollBy(1);
+            return;
+        }
+        if (event.type !== 'key' || event.kind === 'release')
+            return;
+        if (event.key === 'up')
+            this.scrollBy(-1);
+        else if (event.key === 'down')
+            this.scrollBy(1);
+    }
+    scrollBy(delta) {
+        this.stick = false;
+        this.scrollY = Math.max(0, this.scrollY + delta);
+    }
+}
+exports.ScrollView = ScrollView;
+const scrollView = (content) => new ScrollView(content);
+exports.scrollView = scrollView;

package/script/tui/src/components/select-list.d.ts

@@ -0,0 +1,24 @@
+import type { InputEvent } from '../events';
+import type { Component, Surface } from '../surface';
+export interface SelectItem<T> {
+    label: string;
+    value: T;
+}
+export declare class SelectList<T> implements Component {
+    private items;
+    private selected;
+    private top;
+    private readonly maxRows;
+    onSelect?: (item: SelectItem<T>) => void;
+    constructor(items?: SelectItem<T>[], opts?: {
+        maxRows?: number;
+    });
+    setItems(items: SelectItem<T>[]): void;
+    selectedItem(): SelectItem<T> | undefined;
+    move(delta: number): void;
+    render(s: Surface): void;
+    handleInput(event: InputEvent): void;
+}
+export declare const selectList: <T>(items?: SelectItem<T>[], opts?: {
+    maxRows?: number;
+}) => SelectList<T>;

package/script/tui/src/components/select-list.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectList = exports.SelectList = void 0;
+const utils_1 = require("../utils");
+const SELECTED = '\x1b[7m';
+const RESET = '\x1b[0m';
+const pad = (value, width) => {
+    const fitted = (0, utils_1.visibleWidth)(value) > width ? (0, utils_1.truncateToWidth)(value, width) : value;
+    const gap = width - (0, utils_1.visibleWidth)(fitted);
+    return gap > 0 ? fitted + ' '.repeat(gap) : fitted;
+};
+class SelectList {
+    items;
+    selected = 0;
+    top = 0;
+    maxRows;
+    onSelect;
+    constructor(items = [], opts = {}) {
+        this.items = items;
+        this.maxRows = opts.maxRows ?? 10;
+    }
+    setItems(items) {
+        this.items = items;
+        if (this.selected >= items.length)
+            this.selected = Math.max(0, items.length - 1);
+    }
+    selectedItem() {
+        return this.items[this.selected];
+    }
+    move(delta) {
+        if (this.items.length === 0)
+            return;
+        this.selected = (this.selected + delta + this.items.length) % this.items.length;
+    }
+    render(s) {
+        const rows = Math.min(this.items.length, this.maxRows, s.height === Infinity ? this.maxRows : s.height);
+        if (this.selected < this.top)
+            this.top = this.selected;
+        else if (this.selected >= this.top + rows)
+            this.top = this.selected - rows + 1;
+        for (let i = 0; i < rows; i++) {
+            const index = this.top + i;
+            const item = this.items[index];
+            if (!item)
+                break;
+            const line = pad(item.label, s.width);
+            s.text(0, i, index === this.selected ? `${SELECTED}${line}${RESET}` : line);
+        }
+    }
+    handleInput(event) {
+        if (event.type === 'mouse' && event.kind === 'press' && event.button === 'left') {
+            const index = this.top + (event.localY ?? 0);
+            if (index >= 0 && index < this.items.length) {
+                this.selected = index;
+                this.onSelect?.(this.items[index]);
+            }
+            return;
+        }
+        if (event.type !== 'key' || event.kind === 'release')
+            return;
+        if (event.key === 'up')
+            this.move(-1);
+        else if (event.key === 'down')
+            this.move(1);
+        else if (event.key === 'enter') {
+            const item = this.selectedItem();
+            if (item)
+                this.onSelect?.(item);
+        }
+    }
+}
+exports.SelectList = SelectList;
+const selectList = (items, opts) => new SelectList(items ?? [], opts ?? {});
+exports.selectList = selectList;

package/script/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/script/tui/src/events.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_MODIFIERS = void 0;
+exports.NO_MODIFIERS = {
+    shift: false,
+    ctrl: false,
+    alt: false,
+    meta: false,
+};

package/script/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/script/tui/src/index.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapText = exports.visibleWidth = exports.truncateToWidth = exports.mergeCapabilities = exports.createDefaultCapabilities = exports.capability = exports.keyMatches = exports.TerminalInputParser = exports.parseInput = exports.ProcessTerminal = exports.TUI = exports.commandPalette = exports.CommandPalette = exports.selectList = exports.SelectList = exports.scrollView = exports.ScrollView = exports.editor = exports.Editor = exports.toast = exports.text = exports.row = exports.overlay = exports.modal = exports.flex = exports.column = exports.box = exports.renderToBuffer = exports.measureWidth = exports.measure = void 0;
+var surface_1 = require("./surface");
+Object.defineProperty(exports, "measure", { enumerable: true, get: function () { return surface_1.measure; } });
+Object.defineProperty(exports, "measureWidth", { enumerable: true, get: function () { return surface_1.measureWidth; } });
+Object.defineProperty(exports, "renderToBuffer", { enumerable: true, get: function () { return surface_1.renderToBuffer; } });
+var views_1 = require("./views");
+Object.defineProperty(exports, "box", { enumerable: true, get: function () { return views_1.box; } });
+Object.defineProperty(exports, "column", { enumerable: true, get: function () { return views_1.column; } });
+Object.defineProperty(exports, "flex", { enumerable: true, get: function () { return views_1.flex; } });
+Object.defineProperty(exports, "modal", { enumerable: true, get: function () { return views_1.modal; } });
+Object.defineProperty(exports, "overlay", { enumerable: true, get: function () { return views_1.overlay; } });
+Object.defineProperty(exports, "row", { enumerable: true, get: function () { return views_1.row; } });
+Object.defineProperty(exports, "text", { enumerable: true, get: function () { return views_1.text; } });
+Object.defineProperty(exports, "toast", { enumerable: true, get: function () { return views_1.toast; } });
+var editor_1 = require("./components/editor");
+Object.defineProperty(exports, "Editor", { enumerable: true, get: function () { return editor_1.Editor; } });
+Object.defineProperty(exports, "editor", { enumerable: true, get: function () { return editor_1.editor; } });
+var scroll_view_1 = require("./components/scroll-view");
+Object.defineProperty(exports, "ScrollView", { enumerable: true, get: function () { return scroll_view_1.ScrollView; } });
+Object.defineProperty(exports, "scrollView", { enumerable: true, get: function () { return scroll_view_1.scrollView; } });
+var select_list_1 = require("./components/select-list");
+Object.defineProperty(exports, "SelectList", { enumerable: true, get: function () { return select_list_1.SelectList; } });
+Object.defineProperty(exports, "selectList", { enumerable: true, get: function () { return select_list_1.selectList; } });
+var command_palette_1 = require("./components/command-palette");
+Object.defineProperty(exports, "CommandPalette", { enumerable: true, get: function () { return command_palette_1.CommandPalette; } });
+Object.defineProperty(exports, "commandPalette", { enumerable: true, get: function () { return command_palette_1.commandPalette; } });
+var tui_1 = require("./tui");
+Object.defineProperty(exports, "TUI", { enumerable: true, get: function () { return tui_1.TUI; } });
+var terminal_1 = require("./terminal");
+Object.defineProperty(exports, "ProcessTerminal", { enumerable: true, get: function () { return terminal_1.ProcessTerminal; } });
+var keyboard_1 = require("./keyboard");
+Object.defineProperty(exports, "parseInput", { enumerable: true, get: function () { return keyboard_1.parseInput; } });
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "TerminalInputParser", { enumerable: true, get: function () { return parser_1.TerminalInputParser; } });
+var keybinds_1 = require("./keybinds");
+Object.defineProperty(exports, "keyMatches", { enumerable: true, get: function () { return keybinds_1.keyMatches; } });
+var capabilities_1 = require("./capabilities");
+Object.defineProperty(exports, "capability", { enumerable: true, get: function () { return capabilities_1.capability; } });
+Object.defineProperty(exports, "createDefaultCapabilities", { enumerable: true, get: function () { return capabilities_1.createDefaultCapabilities; } });
+Object.defineProperty(exports, "mergeCapabilities", { enumerable: true, get: function () { return capabilities_1.mergeCapabilities; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "truncateToWidth", { enumerable: true, get: function () { return utils_1.truncateToWidth; } });
+Object.defineProperty(exports, "visibleWidth", { enumerable: true, get: function () { return utils_1.visibleWidth; } });
+Object.defineProperty(exports, "wrapText", { enumerable: true, get: function () { return utils_1.wrapText; } });

package/script/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;
+}