@bomb.sh/tty 0.0.0-register.0

package/esm/settings.js

@@ -0,0 +1,61 @@
+import { ALTSCREEN, CSI, ESC, HIDECURSOR, MAINSCREEN, SHOWCURSOR, } from "./termcodes.js";
+export function settings(...sequence) {
+    return {
+        apply: concat(sequence.map((s) => s.apply)),
+        revert: concat(sequence.map((s) => s.revert).reverse()),
+    };
+}
+export function alternateBuffer(options) {
+    return {
+        apply: ALTSCREEN(options),
+        revert: MAINSCREEN(),
+    };
+}
+export function cursor(visible) {
+    if (visible) {
+        return {
+            apply: SHOWCURSOR(),
+            revert: HIDECURSOR(),
+        };
+    }
+    else {
+        return {
+            apply: HIDECURSOR(),
+            revert: SHOWCURSOR(),
+        };
+    }
+}
+/**
+ * Save and restore cursor position using DECSC (`ESC 7`) / DECRC (`ESC 8`).
+ *
+ * @see {@link https://vt100.net/docs/vt510-rm/DECSC.html | VT510 DECSC}
+ * @see {@link https://vt100.net/docs/vt510-rm/DECRC.html | VT510 DECRC}
+ */
+export function saveCursorPosition() {
+    return {
+        apply: ESC("7"),
+        revert: ESC("8"),
+    };
+}
+export function progressiveInput(level) {
+    return {
+        apply: CSI(`>${level}u`),
+        revert: CSI("<u"),
+    };
+}
+export function mouseTracking() {
+    return {
+        apply: concat([CSI("?1003h"), CSI("?1006h")]),
+        revert: concat([CSI("?1006l"), CSI("?1003l")]),
+    };
+}
+function concat(arrays) {
+    let length = arrays.reduce((sum, a) => sum + a.length, 0);
+    let result = new Uint8Array(length);
+    let offset = 0;
+    for (let a of arrays) {
+        result.set(a, offset);
+        offset += a.length;
+    }
+    return result;
+}

package/esm/term-native.d.ts

@@ -0,0 +1,21 @@
+export interface BoundingBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface Native {
+    memory: WebAssembly.Memory;
+    statePtr: number;
+    opsBuf: number;
+    reduce(ct: number, buf: number, len: number, mode: number, row: number): void;
+    output(ct: number): number;
+    length(ct: number): number;
+    setPointer(x: number, y: number, down: boolean): void;
+    getPointerOverIds(): string[];
+    getElementBounds(id: string): BoundingBox | undefined;
+    errorCount(ct: number): number;
+    errorType(ct: number, index: number): number;
+    errorMessage(ct: number, index: number): string;
+}
+export declare function createTermNative(w: number, h: number): Promise<Native>;

package/esm/term-native.js

@@ -0,0 +1,97 @@
+import { f32, offsets, struct } from "./typedef.js";
+const BoundingBoxStruct = struct({
+    x: f32(),
+    y: f32(),
+    width: f32(),
+    height: f32(),
+});
+const BOUNDING_BOX = offsets(BoundingBoxStruct);
+import { compiled } from "./wasm.js";
+export async function createTermNative(w, h) {
+    let memory = new WebAssembly.Memory({ initial: 2 });
+    let exports = {};
+    let instance = await WebAssembly.instantiate(compiled, {
+        env: { memory },
+        clay: {
+            measureTextFunction(ret, text, _config, _userData) {
+                exports.measure(ret, text);
+            },
+            queryScrollOffsetFunction(ret, _elementId, _userData) {
+                let view = new DataView(memory.buffer);
+                view.setFloat32(ret, 0, true);
+                view.setFloat32(ret + 4, 0, true);
+            },
+        },
+    });
+    Object.assign(exports, instance.exports);
+    let ct = exports;
+    let heap = ct.__heap_base.value;
+    let size = ct.clayterm_size(w, h);
+    // grow memory to fit heap + state + ops buffer (1MB headroom for ops)
+    let needed = heap + size + 1024 * 1024;
+    let pages = Math.ceil(needed / 65536);
+    let current = memory.buffer.byteLength / 65536;
+    if (pages > current) {
+        memory.grow(pages - current);
+    }
+    let statePtr = ct.init(heap, w, h);
+    let opsBuf = (heap + size + 3) & ~3;
+    return {
+        memory,
+        statePtr,
+        opsBuf,
+        reduce: ct.reduce,
+        output: ct.output,
+        length: ct.length,
+        setPointer(x, y, down) {
+            let view = new DataView(memory.buffer);
+            view.setFloat32(opsBuf, x, true);
+            view.setFloat32(opsBuf + 4, y, true);
+            ct.Clay_SetPointerState(opsBuf, down ? 1 : 0);
+        },
+        getPointerOverIds() {
+            let decoder = new TextDecoder();
+            let count = ct.pointer_over_count();
+            let ids = [];
+            for (let i = 0; i < count; i++) {
+                let len = ct.pointer_over_id_string_length(i);
+                if (len === 0)
+                    continue;
+                let ptr = ct.pointer_over_id_string_ptr(i);
+                ids.push(decoder.decode(new Uint8Array(memory.buffer, ptr, len)));
+            }
+            return ids;
+        },
+        getElementBounds(id) {
+            let enc = new TextEncoder();
+            let bytes = enc.encode(id);
+            new Uint8Array(memory.buffer).set(bytes, opsBuf);
+            let out = opsBuf + 256;
+            let found = ct.get_element_bounds(opsBuf, bytes.length, out);
+            if (!found) {
+                return undefined;
+            }
+            let view = new DataView(memory.buffer);
+            return {
+                x: view.getFloat32(out + BOUNDING_BOX.x, true),
+                y: view.getFloat32(out + BOUNDING_BOX.y, true),
+                width: view.getFloat32(out + BOUNDING_BOX.width, true),
+                height: view.getFloat32(out + BOUNDING_BOX.height, true),
+            };
+        },
+        errorCount(ptr) {
+            return ct.error_count(ptr);
+        },
+        errorType(ptr, index) {
+            return ct.error_type(ptr, index);
+        },
+        errorMessage(ptr, index) {
+            let len = ct.error_message_length(ptr, index);
+            if (len === 0)
+                return "";
+            let p = ct.error_message_ptr(ptr, index);
+            let decoder = new TextDecoder();
+            return decoder.decode(new Uint8Array(memory.buffer, p, len));
+        },
+    };
+}

package/esm/term.d.ts

@@ -0,0 +1,55 @@
+import { type Op } from "./ops.js";
+import { type BoundingBox } from "./term-native.js";
+export interface TermOptions {
+    height: number;
+    width: number;
+}
+export interface RenderOptions {
+    mode?: "line";
+    /**
+     * Row where to begin rendering. This should only be used when
+     * rendering into a region as part of the CLI main screen. For
+     * interfaces that use the entire screen, leave unset which will
+     * default to 0. This is 1-based which which is the DSR native
+     * format.
+     *
+     * https://www.ecma-international.org/publications-and-standards/standards/ecma-48/
+     */
+    row?: number;
+    pointer?: {
+        x: number;
+        y: number;
+        down: boolean;
+    };
+}
+export type PointerEvent = {
+    type: "pointerenter";
+    id: string;
+} | {
+    type: "pointerleave";
+    id: string;
+} | {
+    type: "pointerclick";
+    id: string;
+};
+export type { BoundingBox };
+export interface ElementInfo {
+    bounds: BoundingBox;
+}
+export interface ClayError {
+    type: string;
+    message: string;
+}
+export interface RenderInfo {
+    get(id: string): ElementInfo | undefined;
+}
+export interface RenderResult {
+    output: Uint8Array;
+    events: PointerEvent[];
+    info: RenderInfo;
+    errors: ClayError[];
+}
+export interface Term {
+    render(ops: Op[], options?: RenderOptions): RenderResult;
+}
+export declare function createTerm(options: TermOptions): Promise<Term>;

package/esm/term.js

@@ -0,0 +1,81 @@
+import { pack } from "./ops.js";
+import { createTermNative } from "./term-native.js";
+const ERROR_TYPES = [
+    "TEXT_MEASUREMENT_FUNCTION_NOT_PROVIDED",
+    "ARENA_CAPACITY_EXCEEDED",
+    "ELEMENTS_CAPACITY_EXCEEDED",
+    "TEXT_MEASUREMENT_CAPACITY_EXCEEDED",
+    "DUPLICATE_ID",
+    "FLOATING_CONTAINER_PARENT_NOT_FOUND",
+    "PERCENTAGE_OVER_1",
+    "INTERNAL_ERROR",
+    "UNBALANCED_OPEN_CLOSE",
+];
+export async function createTerm(options) {
+    let { width, height } = options;
+    let native = await createTermNative(width, height);
+    let { memory, statePtr, opsBuf } = native;
+    let prev = new Set();
+    let pressed = new Set();
+    let wasDown = false;
+    return {
+        render(ops, options) {
+            let len = pack(ops, memory.buffer, opsBuf, memory.buffer.byteLength);
+            let mode = options?.mode === "line" ? 1 : 0;
+            let row = options?.row ?? 1;
+            native.reduce(statePtr, opsBuf, len, mode, row);
+            if (options?.pointer) {
+                let { x, y, down } = options.pointer;
+                native.setPointer(x, y, down);
+            }
+            let output = new Uint8Array(memory.buffer, native.output(statePtr), native.length(statePtr));
+            let current = new Set(options?.pointer ? native.getPointerOverIds() : []);
+            let down = options?.pointer?.down ?? false;
+            let events = [];
+            for (let id of current) {
+                if (!prev.has(id)) {
+                    events.push({ type: "pointerenter", id });
+                }
+            }
+            for (let id of prev) {
+                if (!current.has(id)) {
+                    events.push({ type: "pointerleave", id });
+                }
+            }
+            if (wasDown && !down) {
+                for (let id of pressed) {
+                    if (current.has(id)) {
+                        events.push({ type: "pointerclick", id });
+                    }
+                }
+            }
+            if (down && !wasDown) {
+                pressed = new Set(current);
+            }
+            else if (!down) {
+                pressed.clear();
+            }
+            prev = current;
+            wasDown = down;
+            let info = {
+                get(id) {
+                    let bounds = native.getElementBounds(id);
+                    if (bounds) {
+                        return { bounds };
+                    }
+                    return undefined;
+                },
+            };
+            let errors = [];
+            let count = native.errorCount(statePtr);
+            for (let i = 0; i < count; i++) {
+                let code = native.errorType(statePtr, i);
+                errors.push({
+                    type: ERROR_TYPES[code] ?? `UNKNOWN_${code}`,
+                    message: native.errorMessage(statePtr, i),
+                });
+            }
+            return { output, events, info, errors };
+        },
+    };
+}

package/esm/termcodes.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Encode a plain escape sequence.
+ *
+ * Prepends `ESC` (`\x1b`) to the given string and returns the result as bytes.
+ *
+ * @see {@link https://www.ecma-international.org/publications-and-standards/standards/ecma-48/ | ECMA-48}
+ */
+export declare function ESC(str: string): Uint8Array;
+/**
+ * Encode a Control Sequence Introducer (CSI) command.
+ *
+ * Prepends `ESC[` to the given string and returns the result as bytes.
+ *
+ * @see {@link https://www.ecma-international.org/publications-and-standards/standards/ecma-48/ | ECMA-48}
+ */
+export declare function CSI(str: string): Uint8Array;
+/**
+ * Request the cursor position via Device Status Report (DSR).
+ *
+ * Sends `CSI 6n`. The terminal responds with a Cursor Position Report
+ * (`CSI row ; column R`) where row and column are 1-based.
+ *
+ * @see {@link https://www.ecma-international.org/publications-and-standards/standards/ecma-48/ | ECMA-48}
+ */
+export declare function DSR(): Uint8Array;
+/**
+ * Show the cursor (DECTCEM set).
+ *
+ * DEC private mode 25. Not part of ECMA-48; originates from the VT220.
+ *
+ * @see {@link https://vt100.net/docs/vt510-rm/DECTCEM.html | VT510 DECTCEM}
+ */
+export declare function SHOWCURSOR(): Uint8Array;
+/**
+ * Hide the cursor (DECTCEM reset).
+ *
+ * DEC private mode 25. Not part of ECMA-48; originates from the VT220.
+ *
+ * @see {@link https://vt100.net/docs/vt510-rm/DECTCEM.html | VT510 DECTCEM}
+ */
+export declare function HIDECURSOR(): Uint8Array;
+/**
+ * Switch to the alternate screen buffer.
+ *
+ * Saves the cursor and switches to the alternate screen. When `clear` is
+ * `true` (the default), the alternate buffer is cleared on entry. When
+ * `false`, the existing contents are preserved.
+ *
+ * Use {@link MAINSCREEN} to switch back.
+ *
+ * @see {@link https://invisible-island.net/xterm/ctlseqs/ctlseqs.html | xterm control sequences}
+ */
+export declare function ALTSCREEN(options?: {
+    clear?: boolean;
+}): Uint8Array;
+/**
+ * Switch back to the main screen buffer.
+ *
+ * Restores the cursor and returns to the main screen with scrollback intact.
+ *
+ * @see {@link https://invisible-island.net/xterm/ctlseqs/ctlseqs.html | xterm control sequences}
+ */
+export declare function MAINSCREEN(): Uint8Array;

package/esm/termcodes.js

@@ -0,0 +1,85 @@
+/**
+ * Encode a plain escape sequence.
+ *
+ * Prepends `ESC` (`\x1b`) to the given string and returns the result as bytes.
+ *
+ * @see {@link https://www.ecma-international.org/publications-and-standards/standards/ecma-48/ | ECMA-48}
+ */
+export function ESC(str) {
+    return encode(`\x1b${str}`);
+}
+/**
+ * Encode a Control Sequence Introducer (CSI) command.
+ *
+ * Prepends `ESC[` to the given string and returns the result as bytes.
+ *
+ * @see {@link https://www.ecma-international.org/publications-and-standards/standards/ecma-48/ | ECMA-48}
+ */
+export function CSI(str) {
+    return ESC(`[${str}`);
+}
+/**
+ * Request the cursor position via Device Status Report (DSR).
+ *
+ * Sends `CSI 6n`. The terminal responds with a Cursor Position Report
+ * (`CSI row ; column R`) where row and column are 1-based.
+ *
+ * @see {@link https://www.ecma-international.org/publications-and-standards/standards/ecma-48/ | ECMA-48}
+ */
+export function DSR() {
+    return CSI("6n");
+}
+/**
+ * Show the cursor (DECTCEM set).
+ *
+ * DEC private mode 25. Not part of ECMA-48; originates from the VT220.
+ *
+ * @see {@link https://vt100.net/docs/vt510-rm/DECTCEM.html | VT510 DECTCEM}
+ */
+export function SHOWCURSOR() {
+    return CSI("?25h");
+}
+/**
+ * Hide the cursor (DECTCEM reset).
+ *
+ * DEC private mode 25. Not part of ECMA-48; originates from the VT220.
+ *
+ * @see {@link https://vt100.net/docs/vt510-rm/DECTCEM.html | VT510 DECTCEM}
+ */
+export function HIDECURSOR() {
+    return CSI("?25l");
+}
+/**
+ * Switch to the alternate screen buffer.
+ *
+ * Saves the cursor and switches to the alternate screen. When `clear` is
+ * `true` (the default), the alternate buffer is cleared on entry. When
+ * `false`, the existing contents are preserved.
+ *
+ * Use {@link MAINSCREEN} to switch back.
+ *
+ * @see {@link https://invisible-island.net/xterm/ctlseqs/ctlseqs.html | xterm control sequences}
+ */
+export function ALTSCREEN(options) {
+    let { clear = true } = options ?? {};
+    if (clear) {
+        return CSI("?1049h");
+    }
+    else {
+        return CSI("?47h");
+    }
+}
+/**
+ * Switch back to the main screen buffer.
+ *
+ * Restores the cursor and returns to the main screen with scrollback intact.
+ *
+ * @see {@link https://invisible-island.net/xterm/ctlseqs/ctlseqs.html | xterm control sequences}
+ */
+export function MAINSCREEN() {
+    return CSI("?1049l");
+}
+const encoder = new TextEncoder();
+function encode(str) {
+    return encoder.encode(str);
+}

package/esm/typedef.d.ts

@@ -0,0 +1,44 @@
+export type Attrs<T> = {
+    [K in keyof T]: TypeDef<T[K]>;
+};
+export type Alignment = 1 | 2 | 4 | 8;
+export type LayoutElement<T> = {
+    type: "padding";
+    byteLength: number;
+} | {
+    type: "field";
+    name: string;
+    offset: number;
+    typedef: Attrs<T>[keyof Attrs<T>];
+};
+export type Struct<T> = {
+    type: "struct";
+    byteLength: number;
+    byteAlign: Alignment;
+    layout: LayoutElement<T>[];
+};
+export type Num<T> = {
+    type: "i32" | "f32" | "f64" | "uint8" | "uint16" | "uint32" | "int16" | "int32";
+    byteAlign: Alignment;
+    byteLength: number;
+    T?: T;
+};
+export type Arr<T> = {
+    type: "array";
+    element: TypeDef<T>;
+    length: number;
+    byteLength: number;
+    byteAlign: Alignment;
+};
+export type TypeDef<T> = Num<T> | Struct<T> | Arr<T>;
+export declare function array<T>(element: TypeDef<T>, length: number): Arr<T[]>;
+export declare const f32: () => TypeDef<number>;
+export declare const int32: () => TypeDef<number>;
+export declare const uint8: () => TypeDef<number>;
+export declare const uint16: () => TypeDef<number>;
+export declare const uint32: () => TypeDef<number>;
+export declare function struct<T extends object>(attrs: Attrs<T>): Struct<T>;
+export declare function offsets<T extends object>(def: Struct<T>): {
+    [K in keyof T]: number;
+};
+export declare function pad(offset: number, alignment: number): number;

package/esm/typedef.js

@@ -0,0 +1,84 @@
+export function array(element, length) {
+    return {
+        type: "array",
+        element: element,
+        length,
+        byteLength: element.byteLength * length,
+        byteAlign: element.byteAlign,
+    };
+}
+export const f32 = () => ({
+    type: "f32",
+    byteLength: 4,
+    byteAlign: 4,
+});
+export const int32 = () => ({
+    type: "int32",
+    byteLength: 4,
+    byteAlign: 4,
+});
+export const uint8 = () => ({
+    type: "uint8",
+    byteLength: 1,
+    byteAlign: 1,
+});
+export const uint16 = () => ({
+    type: "uint16",
+    byteLength: 2,
+    byteAlign: 2,
+});
+export const uint32 = () => ({
+    type: "uint32",
+    byteAlign: 4,
+    byteLength: 4,
+});
+export function struct(attrs) {
+    let entries = Object.entries(attrs);
+    let acc = {
+        layout: [],
+        offset: 0,
+    };
+    let byteAlign = Math.max(...entries.map(([, typedef]) => typedef.byteAlign));
+    for (let [name, typedef] of entries) {
+        let padding = pad(acc.offset, typedef.byteAlign);
+        if (padding > 0) {
+            acc.layout.push({ type: "padding", byteLength: padding });
+            acc.offset += padding;
+        }
+        acc.layout.push({
+            type: "field",
+            name: name,
+            offset: acc.offset,
+            typedef,
+        });
+        acc.offset += typedef.byteLength;
+    }
+    let padding = pad(acc.offset, byteAlign);
+    if (padding > 0) {
+        acc.layout.push({ type: "padding", byteLength: padding });
+        acc.offset += padding;
+    }
+    return {
+        type: "struct",
+        layout: acc.layout,
+        byteLength: acc.offset,
+        byteAlign,
+    };
+}
+export function offsets(def) {
+    let result = {};
+    for (let element of def.layout) {
+        if (element.type === "field") {
+            result[element.name] = element.offset;
+        }
+    }
+    return result;
+}
+export function pad(offset, alignment) {
+    if ((offset % alignment) !== 0) {
+        return alignment - (offset % alignment);
+    }
+    else {
+        return 0;
+    }
+}

package/esm/wasm.d.ts

@@ -0,0 +1 @@
+export declare const compiled: any;