@simon_he/vue-tui 0.0.6 → 0.0.8

package/dist/path-suggest-BeV6n7m-.js

@@ -0,0 +1,3 @@
+import { parsePathQuery, resolveUserPath, suggestPaths } from "./path-suggest-DmrmeueH.js";
+
+export { resolveUserPath, suggestPaths };

package/dist/sgr-Tko2EQ0U.js

@@ -0,0 +1,484 @@
+//#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) {
+			var _options$scheduler$ca, _options$scheduler;
+			clearPending();
+			if (wasPending) (_options$scheduler$ca = (_options$scheduler = options.scheduler).cancelFrameTask) === null || _options$scheduler$ca === void 0 || _options$scheduler$ca.call(_options$scheduler, 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) {
+					var _ctx$reportMailboxDel, _ctx$reportDroppedUpd;
+					if (disposed || !hasPending) return;
+					const value$1 = pending;
+					const count = queued;
+					const dropped = Math.max(0, count - 1);
+					clearPending();
+					(_ctx$reportMailboxDel = ctx.reportMailboxDeliveryAttempt) === null || _ctx$reportMailboxDel === void 0 || _ctx$reportMailboxDel.call(ctx, {
+						id: taskId,
+						queued: count,
+						dropped
+					});
+					options.apply(value$1, ctx, {
+						queued: count,
+						dropped
+					});
+					(_ctx$reportDroppedUpd = ctx.reportDroppedUpdates) === null || _ctx$reportDroppedUpd === void 0 || _ctx$reportDroppedUpd.call(ctx, 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() {
+		var _options$scheduler$ca2, _options$scheduler2;
+		const taskId = pendingTaskId;
+		clearPending();
+		if (taskId) (_options$scheduler$ca2 = (_options$scheduler2 = options.scheduler).cancelFrameTask) === null || _options$scheduler$ca2 === void 0 || _options$scheduler$ca2.call(_options$scheduler2, 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
+//#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, createFrameMailbox, defaultActiveStyle, defaultDimStyle, parseAnsiSgr };

package/dist/theme-Bsm65g8k.d.ts

@@ -0,0 +1,32 @@
+import { Style } from "./types-ClIV2h1o.js";
+
+//#region src/vue/markdown/theme.d.ts
+type TuiMarkdownTheme = Readonly<{
+  heading: readonly [Style, Style, Style, Style, Style, Style];
+  strong: Style;
+  emphasis: Style;
+  strikethrough: Style;
+  inlineCode: Style;
+  link: Style;
+  blockquote: Style;
+  listMarker: Style;
+  codeBlock: Style;
+  thematicBreak: Style;
+  html: Style;
+}>;
+type TuiMarkdownThemeOverrides = Readonly<Partial<{
+  heading: readonly Partial<Style>[];
+  strong: Partial<Style>;
+  emphasis: Partial<Style>;
+  strikethrough: Partial<Style>;
+  inlineCode: Partial<Style>;
+  link: Partial<Style>;
+  blockquote: Partial<Style>;
+  listMarker: Partial<Style>;
+  codeBlock: Partial<Style>;
+  thematicBreak: Partial<Style>;
+  html: Partial<Style>;
+}>>;
+
+//#endregion
+export { TuiMarkdownTheme, TuiMarkdownThemeOverrides };

package/dist/types-ClIV2h1o.d.ts

@@ -0,0 +1,103 @@
+//#region src/core/render-plane.d.ts
+declare const TERMINAL_RENDER_PLANES: readonly ["default", "transcript", "chrome", "overlay"];
+type TerminalRenderPlane = (typeof TERMINAL_RENDER_PLANES)[number];
+type TerminalRenderPlanes = readonly TerminalRenderPlane[];
+
+//#endregion
+//#region src/core/types.d.ts
+type ThemeModeId = "dark" | "light";
+type AnsiColorName = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright";
+type Style = Readonly<{
+  /**
+   * Foreground color. Accepts:
+   * - `AnsiColorName` (e.g. `'cyanBright'`) — resolved via palette or standard ANSI codes
+   * - Hex string (e.g. `'#a9dc76'`) — converted to truecolor/ansi256 RGB
+   * - `'transparent'` — resets to terminal default (`\e[39m`)
+   */
+  fg?: string;
+  /**
+   * Background color. Same value space as `fg`.
+   * `'transparent'` resets to terminal default (`\e[49m`).
+   */
+  bg?: string;
+  bold?: boolean;
+  dim?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  inverse?: boolean;
+  /**
+   * Optional terminal hyperlink target (OSC 8).
+   * When set, renderers may emit a clickable hyperlink while keeping text width unchanged.
+   */
+  href?: string;
+}>;
+type Cell = Readonly<{
+  ch: string;
+  width: 1 | 2;
+  continuation?: true;
+  style: Style;
+}>;
+type BufferSnapshot = Readonly<{
+  cols: number;
+  rows: number;
+  lines: readonly string[];
+}>;
+type TerminalSize = Readonly<{
+  cols: number;
+  rows: number;
+}>;
+type TerminalScrollOperation = Readonly<{
+  startY: number;
+  endY: number;
+  delta: number;
+}>;
+type TerminalCommitEvent = Readonly<{
+  dirtyRows: readonly number[] | null;
+  planes: TerminalRenderPlanes | null;
+  /** Renderer hint: try same-frame flush within backend budget; large DOM work may defer. */
+  sync?: boolean;
+  scrollOperations?: readonly TerminalScrollOperation[] | null;
+}>;
+type TerminalResizeEvent = Readonly<{
+  cols: number;
+  rows: number;
+}>;
+interface TerminalEventMap {
+  commit: TerminalCommitEvent;
+  resize: TerminalResizeEvent;
+}
+interface Terminal {
+  resize: (cols: number, rows: number) => void;
+  clear: (x?: number, y?: number, w?: number, h?: number) => void;
+  write: (text: string, opts?: {
+    x?: number;
+    y?: number;
+    style?: Style;
+  }) => void;
+  writeAnsi: (text: string, opts?: {
+    x?: number;
+    y?: number;
+  }) => void;
+  put: (x: number, y: number, ch: string, style?: Style) => void;
+  fill: (x: number, y: number, w: number, h: number, ch?: string, style?: Style) => void;
+  scroll: (lines: number) => void;
+  setCursor: (x: number, y: number, visible?: boolean) => void;
+  batch: <T>(fn: () => T) => T;
+  commit: (meta?: {
+    planes?: TerminalRenderPlanes | null;
+    sync?: boolean;
+  }) => readonly number[] | null;
+  on: <K extends keyof TerminalEventMap>(event: K, cb: (payload: TerminalEventMap[K]) => void) => () => void;
+  dispose: () => void;
+  size: () => TerminalSize;
+  snapshot: () => BufferSnapshot;
+  getCell: (x: number, y: number) => Cell;
+  getRow: (y: number) => readonly Cell[];
+  setScrollbackLimit: (limit: number) => void;
+  getScrollbackLines: (count?: number) => readonly string[];
+  /** Register fingerprint function for SoA pre-computation on the composite buffer. */
+  setFingerprintFn: (fn: (ch: string, style: Style) => number) => void;
+  /** Get pre-computed fingerprints for a composite buffer row (null if not enabled). */
+  getRowFingerprints: (y: number) => Uint32Array | null;
+} //#endregion
+export { AnsiColorName, BufferSnapshot, Cell, Style, TERMINAL_RENDER_PLANES, Terminal, TerminalCommitEvent, TerminalEventMap, TerminalRenderPlane, TerminalRenderPlanes, TerminalResizeEvent, TerminalScrollOperation, ThemeModeId };