@simon_he/vue-tui 0.0.7 → 1.0.0-rc.0

package/dist/runtime.d.cts

@@ -0,0 +1,9 @@
+export type { Rect, TerminalBaseEvent, TerminalDebugNode, TerminalEventHandlerMap, TerminalEventType, TerminalInputEvent, TerminalKeyboardEvent, TerminalNode, TerminalPointerEvent, } from "./events/manager/types.js";
+export type { EventManager } from "./events/manager/event-manager.js";
+export { createEventManager } from "./events/manager/event-manager.js";
+export type { TerminalEventRecord } from "./events/recording.js";
+export type { ClipboardApi, RafApi, Runtime, RuntimeEnv, RuntimeOptions, TimerApi, } from "./runtime/index.js";
+export { createRuntime } from "./runtime/index.js";
+export type { CreateTerminalSelectionControllerOptions, SelectionTextProvider, TerminalSelectionConfig, TerminalSelectionController, TerminalSelectionCopyPayload, TerminalSelectionOptions, TerminalSelectionPoint, TerminalSelectionRange, TerminalSelectionRefreshOptions, TerminalSelectionState, } from "./selection/terminal-selection.js";
+export type { SelectedRowSpan } from "./selection/terminal-selection.js";
+export { createTerminalSelectionController, terminalSelectionRowSpans, terminalSelectionVisibleRowSpans, } from "./selection/terminal-selection.js";

package/dist/runtime.d.ts

@@ -0,0 +1,9 @@
+export type { Rect, TerminalBaseEvent, TerminalDebugNode, TerminalEventHandlerMap, TerminalEventType, TerminalInputEvent, TerminalKeyboardEvent, TerminalNode, TerminalPointerEvent, } from "./events/manager/types.js";
+export type { EventManager } from "./events/manager/event-manager.js";
+export { createEventManager } from "./events/manager/event-manager.js";
+export type { TerminalEventRecord } from "./events/recording.js";
+export type { ClipboardApi, RafApi, Runtime, RuntimeEnv, RuntimeOptions, TimerApi, } from "./runtime/index.js";
+export { createRuntime } from "./runtime/index.js";
+export type { CreateTerminalSelectionControllerOptions, SelectionTextProvider, TerminalSelectionConfig, TerminalSelectionController, TerminalSelectionCopyPayload, TerminalSelectionOptions, TerminalSelectionPoint, TerminalSelectionRange, TerminalSelectionRefreshOptions, TerminalSelectionState, } from "./selection/terminal-selection.js";
+export type { SelectedRowSpan } from "./selection/terminal-selection.js";
+export { createTerminalSelectionController, terminalSelectionRowSpans, terminalSelectionVisibleRowSpans, } from "./selection/terminal-selection.js";

package/dist/runtime.js

@@ -0,0 +1,4 @@
+import { createEventManager, createRuntime } from "./runtime-DtrcQidD.js";
+import { createTerminalSelectionController, terminalSelectionRowSpans, terminalSelectionVisibleRowSpans } from "./terminal-selection-BCOh9jsL.js";
+
+export { createEventManager, createRuntime, createTerminalSelectionController, terminalSelectionRowSpans, terminalSelectionVisibleRowSpans };

package/dist/selection/terminal-selection.d.ts

@@ -0,0 +1,122 @@
+import type { Ref } from "vue";
+import type { Rect } from "../events/manager/types.js";
+import type { ClipboardApi } from "../runtime/index.js";
+import type { Style, Terminal } from "../core/types.js";
+export type TerminalSelectionPoint = Readonly<{
+    x: number;
+    y: number;
+}>;
+export type TerminalSelectionRange = Readonly<{
+    anchor: TerminalSelectionPoint;
+    focus: TerminalSelectionPoint;
+    mode: "linear" | "block";
+}>;
+export type TerminalSelectionState = Readonly<{
+    active: boolean;
+    anchor: TerminalSelectionPoint | null;
+    focus: TerminalSelectionPoint | null;
+    text: string;
+    hasRange: boolean;
+}>;
+export type TerminalSelectionCopyPayload = Readonly<{
+    text: string;
+    rows: number;
+    chars: number;
+    ok: boolean;
+    error?: unknown;
+}>;
+export type TerminalSelectionOptions = Readonly<{
+    autoCopy?: boolean;
+    copyOnMouseUp?: boolean;
+    style?: Style;
+}>;
+export type TerminalSelectionConfig = boolean | TerminalSelectionOptions;
+/**
+ * A visible overlay span in terminal screen coordinates.
+ * Provider-space spans must be translated to screen coordinates before
+ * returning from `getVisibleSpans()`.
+ */
+export type SelectedRowSpan = Readonly<{
+    /** Terminal screen row y */
+    y: number;
+    /** Terminal screen column x inclusive */
+    x0: number;
+    /** Terminal screen column x exclusive */
+    x1: number;
+}>;
+export type SelectionTextProvider = Readonly<{
+    id: string;
+    /**
+     * Current provider viewport rect in terminal screen coordinates.
+     */
+    rect: Rect;
+    /**
+     * Receives a terminal screen-space range. Return true when this provider
+     * can resolve the range without relying on the terminal buffer fallback.
+     */
+    canHandle: (screenRange: TerminalSelectionRange) => boolean;
+    /**
+     * Maps a terminal screen-space point to provider-space point.
+     */
+    pointForCell?: (screenPoint: TerminalSelectionPoint) => TerminalSelectionPoint | null;
+    /**
+     * Receives a provider-space range (i.e. after `pointForCell` mapping).
+     */
+    getText: (providerRange: TerminalSelectionRange) => string;
+    /**
+     * Return overlay highlight spans for the portion of the selection that is
+     * currently visible in the viewport. Coordinates are terminal screen cells.
+     *
+     * When a virtual-scrolling provider scrolls during a drag-selection, the
+     * selection range may span content that has already scrolled out of view.
+     * The default `terminalSelectionRowSpans()` uses screen coordinates and
+     * cannot account for this, so the highlight becomes stale after each scroll
+     * tick. Providers that support cross-viewport selection should implement
+     * this method to return only the spans that intersect the current viewport,
+     * mapped back to screen cell coordinates.
+     *
+     * @param providerRange - The selection range in provider-space coordinates
+     *   (i.e. after `pointForCell` mapping).
+     * @param screenRange - The same selection range in terminal screen
+     *   coordinates (before `pointForCell` mapping).
+     */
+    getVisibleSpans?: (providerRange: TerminalSelectionRange, screenRange: TerminalSelectionRange) => readonly SelectedRowSpan[];
+}>;
+export type TerminalSelectionRefreshOptions = Readonly<{
+    /**
+     * Re-map the current screen-space focus point through the active provider.
+     * Use this for selection-driven auto-scroll after the viewport has moved.
+     */
+    remapFocus?: boolean;
+}>;
+export type TerminalSelectionController = Readonly<{
+    state: Ref<TerminalSelectionState>;
+    start: (point: TerminalSelectionPoint, options?: {
+        extend?: boolean;
+    }) => void;
+    update: (point: TerminalSelectionPoint) => void;
+    finish: () => Promise<void>;
+    clear: () => void;
+    copy: () => Promise<boolean>;
+    paint: (dirtyRows?: readonly number[]) => void;
+    refresh: (options?: TerminalSelectionRefreshOptions) => void;
+    clearProvider: (providerId: string) => void;
+}>;
+type ResolvedSelectionOptions = Readonly<{
+    autoCopy: boolean;
+    copyOnMouseUp: boolean;
+    style: Style;
+}>;
+export type CreateTerminalSelectionControllerOptions = Readonly<{
+    terminal: Terminal;
+    overlayTerminal: Terminal;
+    clipboard: ClipboardApi;
+    getOptions?: () => Partial<ResolvedSelectionOptions>;
+    getTextProviders?: () => readonly SelectionTextProvider[];
+    onDirtyRows?: (rows: readonly number[]) => void;
+    onCopy?: (payload: TerminalSelectionCopyPayload) => void;
+}>;
+export declare function terminalSelectionRowSpans(range: TerminalSelectionRange, cols: number, rows: number): SelectedRowSpan[];
+export declare function terminalSelectionVisibleRowSpans(range: TerminalSelectionRange, cols: number, rows: number, visibleStartY: number, visibleEndY: number): SelectedRowSpan[];
+export declare function createTerminalSelectionController(options: CreateTerminalSelectionControllerOptions): TerminalSelectionController;
+export {};

package/dist/sgr-DMK2AvuT.js

@@ -0,0 +1,304 @@
+//#region src/core/ansi/sgr.ts
+const ESC = "\x1B";
+function ansi16ToColorName(code) {
+	switch (code) {
+		case 30: return "black";
+		case 31: return "red";
+		case 32: return "green";
+		case 33: return "yellow";
+		case 34: return "blue";
+		case 35: return "magenta";
+		case 36: return "cyan";
+		case 37: return "white";
+		case 90: return "blackBright";
+		case 91: return "redBright";
+		case 92: return "greenBright";
+		case 93: return "yellowBright";
+		case 94: return "blueBright";
+		case 95: return "magentaBright";
+		case 96: return "cyanBright";
+		case 97: return "whiteBright";
+		default: return void 0;
+	}
+}
+function ansi16BgToColorName(code) {
+	const fgCode = code >= 40 && code <= 47 ? code - 10 : code >= 100 && code <= 107 ? code - 10 : null;
+	if (fgCode == null) return void 0;
+	return ansi16ToColorName(fgCode);
+}
+const ANSI16_RGB = {
+	black: {
+		r: 0,
+		g: 0,
+		b: 0
+	},
+	red: {
+		r: 201,
+		g: 27,
+		b: 0
+	},
+	green: {
+		r: 0,
+		g: 194,
+		b: 0
+	},
+	yellow: {
+		r: 199,
+		g: 196,
+		b: 0
+	},
+	blue: {
+		r: 2,
+		g: 37,
+		b: 199
+	},
+	magenta: {
+		r: 201,
+		g: 48,
+		b: 199
+	},
+	cyan: {
+		r: 0,
+		g: 197,
+		b: 199
+	},
+	white: {
+		r: 199,
+		g: 199,
+		b: 199
+	},
+	blackBright: {
+		r: 104,
+		g: 104,
+		b: 104
+	},
+	redBright: {
+		r: 255,
+		g: 110,
+		b: 103
+	},
+	greenBright: {
+		r: 95,
+		g: 250,
+		b: 104
+	},
+	yellowBright: {
+		r: 255,
+		g: 252,
+		b: 103
+	},
+	blueBright: {
+		r: 104,
+		g: 113,
+		b: 255
+	},
+	magentaBright: {
+		r: 255,
+		g: 118,
+		b: 255
+	},
+	cyanBright: {
+		r: 95,
+		g: 253,
+		b: 255
+	},
+	whiteBright: {
+		r: 255,
+		g: 255,
+		b: 255
+	}
+};
+function nearestAnsi16(r, g, b) {
+	let best = "white";
+	let bestDist = Number.POSITIVE_INFINITY;
+	for (const [name, rgb] of Object.entries(ANSI16_RGB)) {
+		const dr = r - rgb.r;
+		const dg = g - rgb.g;
+		const db = b - rgb.b;
+		const d = dr * dr + dg * dg + db * db;
+		if (d < bestDist) {
+			bestDist = d;
+			best = name;
+		}
+	}
+	return best;
+}
+function ansi256ToRgb(index) {
+	const n = Math.max(0, Math.min(255, Math.trunc(index)));
+	if (n < 16) {
+		const map = [
+			"black",
+			"red",
+			"green",
+			"yellow",
+			"blue",
+			"magenta",
+			"cyan",
+			"white",
+			"blackBright",
+			"redBright",
+			"greenBright",
+			"yellowBright",
+			"blueBright",
+			"magentaBright",
+			"cyanBright",
+			"whiteBright"
+		];
+		const name = map[n] ?? "white";
+		return ANSI16_RGB[name];
+	}
+	if (n >= 232) {
+		const c = 8 + (n - 232) * 10;
+		return {
+			r: c,
+			g: c,
+			b: c
+		};
+	}
+	const i = n - 16;
+	const rr = Math.floor(i / 36);
+	const gg = Math.floor(i % 36 / 6);
+	const bb = i % 6;
+	const toComponent = (v) => v === 0 ? 0 : 55 + v * 40;
+	return {
+		r: toComponent(rr),
+		g: toComponent(gg),
+		b: toComponent(bb)
+	};
+}
+function applyAnsiSgrStyle(current, codes) {
+	let next = { ...current };
+	for (let i = 0; i < codes.length; i++) {
+		const code = codes[i];
+		if (code === 0) {
+			next = {};
+			continue;
+		}
+		if (code === 1) next = {
+			...next,
+			bold: true
+		};
+		else if (code === 2) next = {
+			...next,
+			dim: true
+		};
+		else if (code === 3) next = {
+			...next,
+			italic: true
+		};
+		else if (code === 4) next = {
+			...next,
+			underline: true
+		};
+		else if (code === 7) next = {
+			...next,
+			inverse: true
+		};
+		else if (code === 22) next = {
+			...next,
+			bold: false,
+			dim: false
+		};
+		else if (code === 23) next = {
+			...next,
+			italic: false
+		};
+		else if (code === 24) next = {
+			...next,
+			underline: false
+		};
+		else if (code === 27) next = {
+			...next,
+			inverse: false
+		};
+		else if (code === 39) next = {
+			...next,
+			fg: void 0
+		};
+		else if (code === 49) next = {
+			...next,
+			bg: void 0
+		};
+		else if (code >= 30 && code <= 37 || code >= 90 && code <= 97) {
+			const fg = ansi16ToColorName(code);
+			next = {
+				...next,
+				fg: fg ?? next.fg
+			};
+		} else if (code >= 40 && code <= 47 || code >= 100 && code <= 107) {
+			const bg = ansi16BgToColorName(code);
+			next = {
+				...next,
+				bg: bg ?? next.bg
+			};
+		} else if (code === 38 || code === 48) {
+			const mode = codes[i + 1];
+			if (mode === 5) {
+				const idx = codes[i + 2];
+				if (idx != null) {
+					const { r, g, b } = ansi256ToRgb(idx);
+					const name = nearestAnsi16(r, g, b);
+					next = code === 38 ? {
+						...next,
+						fg: name
+					} : {
+						...next,
+						bg: name
+					};
+				}
+				i += 2;
+			} else if (mode === 2) {
+				const r = codes[i + 2];
+				const g = codes[i + 3];
+				const b = codes[i + 4];
+				if (r != null && g != null && b != null) {
+					const name = nearestAnsi16(r, g, b);
+					next = code === 38 ? {
+						...next,
+						fg: name
+					} : {
+						...next,
+						bg: name
+					};
+				}
+				i += 4;
+			}
+		}
+	}
+	return next;
+}
+function parseAnsiSgr(input, baseStyle = {}) {
+	const segments = [];
+	let style = { ...baseStyle };
+	let lastIndex = 0;
+	for (let i = 0; i < input.length; i++) {
+		if (input[i] !== ESC || input[i + 1] !== "[") continue;
+		let j = i + 2;
+		while (j < input.length) {
+			const c = input.charCodeAt(j);
+			if (c >= 48 && c <= 57 || c === 59) {
+				j++;
+				continue;
+			}
+			break;
+		}
+		if (j >= input.length || input[j] !== "m") continue;
+		if (i > lastIndex) segments.push({
+			text: input.slice(lastIndex, i),
+			style
+		});
+		const body = input.slice(i + 2, j);
+		const codes = body.split(";").filter(Boolean).map((n) => Number.parseInt(n, 10)).filter((n) => Number.isFinite(n));
+		style = applyAnsiSgrStyle(style, codes.length ? codes : [0]);
+		lastIndex = j + 1;
+		i = j;
+	}
+	if (lastIndex < input.length) segments.push({
+		text: input.slice(lastIndex),
+		style
+	});
+	return segments;
+}
+
+//#endregion
+export { applyAnsiSgrStyle, parseAnsiSgr };

package/dist/style-cache-i0ZABZRq.js

@@ -0,0 +1,178 @@
+//#region src/vue/scheduler/frame-mailbox.ts
+const EMPTY = Symbol("frame-mailbox-empty");
+/**
+* Coalesces many producer updates into a single scheduler frame task.
+*
+* This helper is currently internal to vue-tui. It is used by library
+* components and internal tests, but it is not exported from the package root.
+*
+* Default behavior keeps only the latest queued value. If `merge` is provided,
+* the pending value is updated with `merge(prev, next)`.
+*
+* Only the first queue() call in a pending cycle schedules a frame task.
+* Later queue() calls update the pending payload and are reported as dropped
+* producer updates when the frame task runs.
+*
+* droppedUpdates are reported after apply() succeeds. They only appear in
+* framePerf when apply() also invalidates and produces a rendered frame sample.
+* If apply() throws, scheduler error stats include mailbox queued/dropped
+* metadata for the failed delivery attempt. The pending payload has already
+* been cleared; mailbox delivery is fail-fast and does not retry stale payloads
+* on later frames.
+*
+* cancel() is best-effort at scheduler level. The run callback still guards
+* `disposed || !hasPending`, because a scheduler may already have taken a
+* snapshot of tasks for the current frame.
+*
+* queue() returns false only when the scheduler explicitly rejects the task.
+* Legacy void-returning schedulers are treated as accepted for compatibility.
+* Owners should call dispose() before the component/scope that owns the
+* mailbox is destroyed.
+*
+* id is scheduler-global. Components should include instance id and producer
+* name, for example `TList:${uid}:wheel`.
+*/
+function createFrameMailbox(options) {
+	let disposed = false;
+	let hasPending = false;
+	let pending = EMPTY;
+	let queued = 0;
+	let pendingTaskId = null;
+	function clearPending() {
+		hasPending = false;
+		pending = EMPTY;
+		queued = 0;
+		pendingTaskId = null;
+	}
+	function currentTaskId() {
+		if (pendingTaskId) return pendingTaskId;
+		const id = typeof options.id === "function" ? options.id() : options.id;
+		if (!id) throw new Error("createFrameMailbox requires a non-empty task id");
+		pendingTaskId = id;
+		return pendingTaskId;
+	}
+	function queue(value) {
+		if (disposed) return false;
+		const wasPending = hasPending;
+		const taskId = wasPending ? pendingTaskId : currentTaskId();
+		let nextPending;
+		try {
+			nextPending = hasPending && options.merge ? options.merge(pending, value) : value;
+		} catch (error) {
+			clearPending();
+			if (wasPending) options.scheduler.cancelFrameTask?.(taskId);
+			throw error;
+		}
+		pending = nextPending;
+		hasPending = true;
+		queued++;
+		if (wasPending) return true;
+		let accepted;
+		try {
+			accepted = options.scheduler.queueFrameTask({
+				id: taskId,
+				reason: options.reason,
+				priority: options.priority,
+				sync: options.sync,
+				run(ctx) {
+					if (disposed || !hasPending) return;
+					const value$1 = pending;
+					const count = queued;
+					const dropped = Math.max(0, count - 1);
+					clearPending();
+					ctx.reportMailboxDeliveryAttempt?.({
+						id: taskId,
+						queued: count,
+						dropped
+					});
+					options.apply(value$1, ctx, {
+						queued: count,
+						dropped
+					});
+					ctx.reportDroppedUpdates?.(dropped);
+				}
+			});
+		} catch (error) {
+			clearPending();
+			throw error;
+		}
+		if (accepted === false) {
+			clearPending();
+			return false;
+		}
+		return true;
+	}
+	function replacePending(value) {
+		if (disposed) return false;
+		if (!hasPending) return queue(value);
+		pending = value;
+		return true;
+	}
+	function cancel() {
+		const taskId = pendingTaskId;
+		clearPending();
+		if (taskId) options.scheduler.cancelFrameTask?.(taskId);
+	}
+	function dispose() {
+		cancel();
+		disposed = true;
+	}
+	return {
+		queue,
+		replacePending,
+		cancel,
+		dispose,
+		hasPending: () => hasPending,
+		peek: () => hasPending ? pending : void 0
+	};
+}
+
+//#endregion
+//#region src/vue/utils/style-cache.ts
+const EMPTY_STYLE = Object.freeze({});
+const inverseStyleCache = new WeakMap();
+const dimStyleCache = new WeakMap();
+function cacheBase(base) {
+	for (const key in base) if (Object.prototype.hasOwnProperty.call(base, key)) return base;
+	return EMPTY_STYLE;
+}
+function cacheable(base) {
+	return Object.isFrozen(base);
+}
+function defaultActiveStyle(base) {
+	if (base.inverse) return base;
+	base = cacheBase(base);
+	if (!cacheable(base)) return {
+		...base,
+		inverse: true
+	};
+	let cached = inverseStyleCache.get(base);
+	if (!cached) {
+		cached = Object.freeze({
+			...base,
+			inverse: true
+		});
+		inverseStyleCache.set(base, cached);
+	}
+	return cached;
+}
+function defaultDimStyle(base) {
+	if (base.dim) return base;
+	base = cacheBase(base);
+	if (!cacheable(base)) return {
+		...base,
+		dim: true
+	};
+	let cached = dimStyleCache.get(base);
+	if (!cached) {
+		cached = Object.freeze({
+			...base,
+			dim: true
+		});
+		dimStyleCache.set(base, cached);
+	}
+	return cached;
+}
+
+//#endregion
+export { createFrameMailbox, defaultActiveStyle, defaultDimStyle };