@vui-rs/core 0.1.0

package/dist/terminal-session.js

@@ -0,0 +1,82 @@
+//#region src/terminal-session.ts
+const decoder = new TextDecoder();
+const ENTER_ALT = "\x1B[?1049h";
+const LEAVE_ALT = "\x1B[?1049l";
+const KITTY_KBD_ON = "\x1B[>1u";
+const KITTY_KBD_OFF = "\x1B[<u";
+function toText(chunk) {
+	if (typeof chunk === "string") return chunk;
+	if (chunk instanceof Uint8Array) return decoder.decode(chunk);
+	return String(chunk);
+}
+function createTerminalSession(options = {}) {
+	const input = options.input ?? process.stdin;
+	const output = options.output ?? process.stdout;
+	const altScreen = options.altScreen ?? true;
+	const installSignals = options.installSignalHandlers ?? true;
+	const kittyKeyboard = options.kittyKeyboard ?? true;
+	let started = false;
+	let restored = false;
+	let dataCb = null;
+	let resizeCb = null;
+	const onDataRaw = (chunk) => dataCb?.(toText(chunk));
+	const onResizeRaw = () => resizeCb?.(output.columns ?? 0, output.rows ?? 0);
+	const onSignal = () => {
+		stop();
+		process.exit(0);
+	};
+	const onUncaught = (err) => {
+		stop();
+		process.nextTick(() => {
+			throw err;
+		});
+	};
+	function start() {
+		if (started) return;
+		started = true;
+		input.setRawMode?.(true);
+		output.write((altScreen ? ENTER_ALT : "") + "\x1B[?25l\x1B[?2004h\x1B[?1006h\x1B[?1000h\x1B[?1002h" + (kittyKeyboard ? KITTY_KBD_ON : ""));
+		input.resume?.();
+		input.on("data", onDataRaw);
+		output.on("resize", onResizeRaw);
+		if (installSignals) {
+			process.once("exit", stop);
+			process.once("SIGINT", onSignal);
+			process.once("SIGTERM", onSignal);
+			process.once("uncaughtException", onUncaught);
+		}
+	}
+	function stop() {
+		if (restored) return;
+		restored = true;
+		input.off("data", onDataRaw);
+		output.off("resize", onResizeRaw);
+		input.setRawMode?.(false);
+		input.pause?.();
+		output.write((kittyKeyboard ? KITTY_KBD_OFF : "") + "\x1B[?1002l\x1B[?1000l\x1B[?1006l\x1B[?2004l\x1B[?25h" + (altScreen ? LEAVE_ALT : ""));
+		if (installSignals) {
+			process.off("exit", stop);
+			process.off("SIGINT", onSignal);
+			process.off("SIGTERM", onSignal);
+			process.off("uncaughtException", onUncaught);
+		}
+	}
+	return {
+		start,
+		stop,
+		onData: (cb) => {
+			dataCb = cb;
+		},
+		onResize: (cb) => {
+			resizeCb = cb;
+		},
+		get size() {
+			return {
+				cols: output.columns ?? 0,
+				rows: output.rows ?? 0
+			};
+		}
+	};
+}
+//#endregion
+export { createTerminalSession };

package/dist/text/edit-buffer.d.ts

@@ -0,0 +1,31 @@
+import { EditMotion, EditMotionCode } from "../native/ffi-symbols.js";
+import { Pointer } from "bun:ffi";
+
+//#region src/text/edit-buffer.d.ts
+declare class EditBuffer {
+  #private;
+  constructor(value?: string);
+  get nativePtr(): Pointer;
+  getValue(): string;
+  setValue(value: string): void;
+  insert(text: string): void;
+  newline(): void;
+  backspace(): void;
+  delete(): void;
+  move(motion: EditMotionCode, selecting?: boolean): void;
+  selectAll(): void;
+  hasSelection(): boolean;
+  selectedText(): string;
+  deleteSelection(): boolean;
+  undo(): boolean;
+  redo(): boolean;
+  canUndo(): boolean;
+  canRedo(): boolean;
+  cursor(): {
+    row: number;
+    col: number;
+  };
+  free(): void;
+}
+//#endregion
+export { EditBuffer };

package/dist/text/edit-buffer.js

@@ -0,0 +1,96 @@
+import { Status } from "../native/ffi-symbols.js";
+import { loadNativeLib } from "../native/load-native-lib.js";
+//#region src/text/edit-buffer.ts
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+function check(status, op) {
+	if (status !== Status.OK) throw new Error(`vui-core ${op} failed with status ${status}`);
+}
+var EditBuffer = class {
+	#lib = loadNativeLib();
+	#ptr;
+	#cursor = new Uint32Array(2);
+	#changed = new Uint32Array(1);
+	constructor(value = "") {
+		const ptr = this.#lib.symbols.vui_editbuf_new();
+		if (ptr === null) throw new Error("vui-core: failed to allocate EditBuffer");
+		this.#ptr = ptr;
+		if (value) this.setValue(value);
+	}
+	get nativePtr() {
+		return this.#ptr;
+	}
+	getValue() {
+		const len = Number(this.#lib.symbols.vui_editbuf_value_len(this.#ptr));
+		if (len === 0) return "";
+		const out = new Uint8Array(len);
+		const copied = Number(this.#lib.symbols.vui_editbuf_copy_value(this.#ptr, out, out.byteLength));
+		return decoder.decode(out.subarray(0, copied));
+	}
+	setValue(value) {
+		const bytes = encoder.encode(value);
+		check(this.#lib.symbols.vui_editbuf_set_value(this.#ptr, bytes, bytes.byteLength), "editbuf_set_value");
+	}
+	insert(text) {
+		const bytes = encoder.encode(text);
+		check(this.#lib.symbols.vui_editbuf_insert(this.#ptr, bytes, bytes.byteLength), "editbuf_insert");
+	}
+	newline() {
+		check(this.#lib.symbols.vui_editbuf_newline(this.#ptr), "editbuf_newline");
+	}
+	backspace() {
+		check(this.#lib.symbols.vui_editbuf_backspace(this.#ptr), "editbuf_backspace");
+	}
+	delete() {
+		check(this.#lib.symbols.vui_editbuf_delete(this.#ptr), "editbuf_delete");
+	}
+	move(motion, selecting = false) {
+		check(this.#lib.symbols.vui_editbuf_move(this.#ptr, motion, selecting ? 1 : 0), "editbuf_move");
+	}
+	selectAll() {
+		check(this.#lib.symbols.vui_editbuf_select_all(this.#ptr), "editbuf_select_all");
+	}
+	hasSelection() {
+		return this.#lib.symbols.vui_editbuf_has_selection(this.#ptr) !== 0;
+	}
+	selectedText() {
+		const len = Number(this.#lib.symbols.vui_editbuf_selected_len(this.#ptr));
+		if (len === 0) return "";
+		const out = new Uint8Array(len);
+		const copied = Number(this.#lib.symbols.vui_editbuf_copy_selected(this.#ptr, out, out.byteLength));
+		return decoder.decode(out.subarray(0, copied));
+	}
+	deleteSelection() {
+		check(this.#lib.symbols.vui_editbuf_delete_selection(this.#ptr, this.#changed), "editbuf_delete_selection");
+		return this.#changed[0] === 1;
+	}
+	undo() {
+		check(this.#lib.symbols.vui_editbuf_undo(this.#ptr, this.#changed), "editbuf_undo");
+		return this.#changed[0] === 1;
+	}
+	redo() {
+		check(this.#lib.symbols.vui_editbuf_redo(this.#ptr, this.#changed), "editbuf_redo");
+		return this.#changed[0] === 1;
+	}
+	canUndo() {
+		return this.#lib.symbols.vui_editbuf_can_undo(this.#ptr) !== 0;
+	}
+	canRedo() {
+		return this.#lib.symbols.vui_editbuf_can_redo(this.#ptr) !== 0;
+	}
+	cursor() {
+		check(this.#lib.symbols.vui_editbuf_cursor(this.#ptr, this.#cursor, this.#cursor.subarray(1)), "editbuf_cursor");
+		return {
+			row: this.#cursor[0],
+			col: this.#cursor[1]
+		};
+	}
+	free() {
+		if (this.#ptr !== null) {
+			this.#lib.symbols.vui_editbuf_free(this.#ptr);
+			this.#ptr = null;
+		}
+	}
+};
+//#endregion
+export { EditBuffer };

package/dist/text/editor-view.d.ts

@@ -0,0 +1,22 @@
+import { EditMotionCode } from "../native/ffi-symbols.js";
+import { TextWrapMode } from "./text-buffer-view.js";
+import { EditBuffer } from "./edit-buffer.js";
+import { Pointer } from "bun:ffi";
+
+//#region src/text/editor-view.d.ts
+declare class EditorView {
+  #private;
+  constructor(edit: EditBuffer, width?: number, height?: number, mode?: TextWrapMode);
+  get nativePtr(): Pointer;
+  setWrap(mode: TextWrapMode): void;
+  setViewport(width: number, height: number): void;
+  setFocused(focused: boolean): void;
+  move(motion: EditMotionCode, selecting?: boolean): void;
+  measure(width: number, mode?: TextWrapMode): {
+    lineCount: number;
+    maxWidth: number;
+  };
+  free(): void;
+}
+//#endregion
+export { EditorView };

package/dist/text/editor-view.js

@@ -0,0 +1,48 @@
+import { Status } from "../native/ffi-symbols.js";
+import { loadNativeLib } from "../native/load-native-lib.js";
+import { wrapCode } from "./text-buffer-view.js";
+//#region src/text/editor-view.ts
+function check(status, op) {
+	if (status !== Status.OK) throw new Error(`vui-core ${op} failed with status ${status}`);
+}
+var EditorView = class {
+	#lib = loadNativeLib();
+	#ptr;
+	#measure = new Uint32Array(2);
+	constructor(edit, width = 1, height = 1, mode = "word") {
+		const ptr = this.#lib.symbols.vui_editor_new(edit.nativePtr, Math.max(1, width), Math.max(1, height));
+		if (ptr === null) throw new Error("vui-core: failed to allocate EditorView");
+		this.#ptr = ptr;
+		this.setWrap(mode);
+	}
+	get nativePtr() {
+		return this.#ptr;
+	}
+	setWrap(mode) {
+		check(this.#lib.symbols.vui_editor_set_wrap(this.#ptr, wrapCode(mode)), "editor_set_wrap");
+	}
+	setViewport(width, height) {
+		check(this.#lib.symbols.vui_editor_set_viewport(this.#ptr, Math.max(1, Math.floor(width)), Math.max(1, Math.floor(height))), "editor_set_viewport");
+	}
+	setFocused(focused) {
+		check(this.#lib.symbols.vui_editor_set_focused(this.#ptr, focused ? 1 : 0), "editor_set_focused");
+	}
+	move(motion, selecting = false) {
+		check(this.#lib.symbols.vui_editor_move(this.#ptr, motion, selecting ? 1 : 0), "editor_move");
+	}
+	measure(width, mode = "word") {
+		check(this.#lib.symbols.vui_editor_measure(this.#ptr, Math.max(1, Math.floor(width)), wrapCode(mode), this.#measure), "editor_measure");
+		return {
+			lineCount: this.#measure[0],
+			maxWidth: this.#measure[1]
+		};
+	}
+	free() {
+		if (this.#ptr !== null) {
+			this.#lib.symbols.vui_editor_free(this.#ptr);
+			this.#ptr = null;
+		}
+	}
+};
+//#endregion
+export { EditorView };

package/dist/text/index.d.ts

@@ -0,0 +1,5 @@
+import { EditMotion, EditMotionCode } from "../native/ffi-symbols.js";
+import { TextBuffer } from "./text-buffer.js";
+import { TextBufferView, TextMeasure, TextWrapMode, wrapCode } from "./text-buffer-view.js";
+import { EditBuffer } from "./edit-buffer.js";
+import { EditorView } from "./editor-view.js";

package/dist/text/index.js

@@ -0,0 +1,5 @@
+import "../native/ffi-symbols.js";
+import "./text-buffer.js";
+import "./text-buffer-view.js";
+import "./edit-buffer.js";
+import "./editor-view.js";

package/dist/text/text-buffer-view.d.ts

@@ -0,0 +1,22 @@
+import { NativeTextWrapCode } from "../native/ffi-symbols.js";
+import { TextBuffer } from "./text-buffer.js";
+import { Pointer } from "bun:ffi";
+
+//#region src/text/text-buffer-view.d.ts
+type TextWrapMode = 'nowrap' | 'char' | 'word';
+interface TextMeasure {
+  lineCount: number;
+  maxWidth: number;
+}
+declare function wrapCode(mode: TextWrapMode): NativeTextWrapCode;
+declare class TextBufferView {
+  #private;
+  constructor(buffer: TextBuffer, width?: number, mode?: TextWrapMode);
+  get nativePtr(): Pointer;
+  setWidth(width: number): void;
+  setWrap(mode: TextWrapMode): void;
+  measure(width: number, mode?: TextWrapMode): TextMeasure;
+  free(): void;
+}
+//#endregion
+export { TextBufferView, TextMeasure, TextWrapMode, wrapCode };

package/dist/text/text-buffer-view.js

@@ -0,0 +1,49 @@
+import { NativeTextWrap, Status } from "../native/ffi-symbols.js";
+import { loadNativeLib } from "../native/load-native-lib.js";
+//#region src/text/text-buffer-view.ts
+function check(status, op) {
+	if (status !== Status.OK) throw new Error(`vui-core ${op} failed with status ${status}`);
+}
+function wrapCode(mode) {
+	switch (mode) {
+		case "nowrap": return NativeTextWrap.None;
+		case "char": return NativeTextWrap.Char;
+		case "word": return NativeTextWrap.Word;
+	}
+}
+var TextBufferView = class {
+	#lib = loadNativeLib();
+	#ptr;
+	#measure = new Uint32Array(2);
+	constructor(buffer, width = 1, mode = "word") {
+		const ptr = this.#lib.symbols.vui_textview_new(buffer.nativePtr);
+		if (ptr === null) throw new Error("vui-core: failed to allocate TextBufferView");
+		this.#ptr = ptr;
+		this.setWidth(width);
+		this.setWrap(mode);
+	}
+	get nativePtr() {
+		return this.#ptr;
+	}
+	setWidth(width) {
+		check(this.#lib.symbols.vui_textview_set_width(this.#ptr, Math.max(1, Math.floor(width))), "textview_set_width");
+	}
+	setWrap(mode) {
+		check(this.#lib.symbols.vui_textview_set_wrap(this.#ptr, wrapCode(mode)), "textview_set_wrap");
+	}
+	measure(width, mode = "word") {
+		check(this.#lib.symbols.vui_textview_measure(this.#ptr, Math.max(1, Math.floor(width)), wrapCode(mode), this.#measure), "textview_measure");
+		return {
+			lineCount: this.#measure[0],
+			maxWidth: this.#measure[1]
+		};
+	}
+	free() {
+		if (this.#ptr !== null) {
+			this.#lib.symbols.vui_textview_free(this.#ptr);
+			this.#ptr = null;
+		}
+	}
+};
+//#endregion
+export { TextBufferView, wrapCode };

package/dist/text/text-buffer.d.ts

@@ -0,0 +1,16 @@
+import { TextRun } from "../node.js";
+import { Pointer } from "bun:ffi";
+
+//#region src/text/text-buffer.d.ts
+declare class TextBuffer {
+  #private;
+  constructor(text?: string);
+  get nativePtr(): Pointer;
+  setText(text: string): void;
+  setRuns(runs: TextRun[]): void;
+  lineCount(): number;
+  length(): number;
+  free(): void;
+}
+//#endregion
+export { TextBuffer };

package/dist/text/text-buffer.js

@@ -0,0 +1,43 @@
+import { Status } from "../native/ffi-symbols.js";
+import { loadNativeLib } from "../native/load-native-lib.js";
+import { packTextRuns } from "../node.js";
+//#region src/text/text-buffer.ts
+const encoder = new TextEncoder();
+function check(status, op) {
+	if (status !== Status.OK) throw new Error(`vui-core ${op} failed with status ${status}`);
+}
+var TextBuffer = class {
+	#lib = loadNativeLib();
+	#ptr;
+	constructor(text = "") {
+		const ptr = this.#lib.symbols.vui_textbuf_new();
+		if (ptr === null) throw new Error("vui-core: failed to allocate TextBuffer");
+		this.#ptr = ptr;
+		if (text) this.setText(text);
+	}
+	get nativePtr() {
+		return this.#ptr;
+	}
+	setText(text) {
+		const bytes = encoder.encode(text);
+		check(this.#lib.symbols.vui_textbuf_set_text(this.#ptr, bytes, bytes.byteLength), "textbuf_set_text");
+	}
+	setRuns(runs) {
+		const { bytes, runBytes } = packTextRuns(runs);
+		check(this.#lib.symbols.vui_textbuf_set_runs(this.#ptr, runBytes, runs.length, bytes, bytes.byteLength), "textbuf_set_runs");
+	}
+	lineCount() {
+		return this.#lib.symbols.vui_textbuf_line_count(this.#ptr);
+	}
+	length() {
+		return this.#lib.symbols.vui_textbuf_length(this.#ptr);
+	}
+	free() {
+		if (this.#ptr !== null) {
+			this.#lib.symbols.vui_textbuf_free(this.#ptr);
+			this.#ptr = null;
+		}
+	}
+};
+//#endregion
+export { TextBuffer };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@vui-rs/core",
+  "version": "0.1.0",
+  "description": "Native terminal rendering engine for vui-rs — a Rust cell buffer (truecolor, unicode, borders, taffy layout, images) driven from Bun via FFI.",
+  "keywords": [
+    "bun",
+    "ffi",
+    "renderer",
+    "rust",
+    "terminal",
+    "tui",
+    "vui-rs"
+  ],
+  "homepage": "https://github.com/open-ai-sdk/vui-rs#readme",
+  "bugs": "https://github.com/open-ai-sdk/vui-rs/issues",
+  "license": "MIT",
+  "author": "evann <dacsang97@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/open-ai-sdk/vui-rs.git",
+    "directory": "packages/core"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "module": "src/index.ts",
+  "types": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "publishConfig": {
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js"
+      }
+    },
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown"
+  }
+}