@zaly/tui 0.0.4

package/dist/kitty-JbCJC0iQ.mjs

@@ -0,0 +1,673 @@
+import { isSSH } from "@zaly/shared/env";
+//#region src/image/kitty.ts
+const DIACRITICS = [
+	773,
+	781,
+	782,
+	784,
+	786,
+	829,
+	830,
+	831,
+	838,
+	842,
+	843,
+	844,
+	848,
+	849,
+	850,
+	855,
+	859,
+	867,
+	868,
+	869,
+	870,
+	871,
+	872,
+	873,
+	874,
+	875,
+	876,
+	877,
+	878,
+	879,
+	1155,
+	1156,
+	1157,
+	1158,
+	1159,
+	1426,
+	1427,
+	1428,
+	1429,
+	1431,
+	1432,
+	1433,
+	1436,
+	1437,
+	1438,
+	1439,
+	1440,
+	1441,
+	1448,
+	1449,
+	1451,
+	1452,
+	1455,
+	1476,
+	1552,
+	1553,
+	1554,
+	1555,
+	1556,
+	1557,
+	1558,
+	1559,
+	1623,
+	1624,
+	1625,
+	1626,
+	1627,
+	1629,
+	1630,
+	1750,
+	1751,
+	1752,
+	1753,
+	1754,
+	1755,
+	1756,
+	1759,
+	1760,
+	1761,
+	1762,
+	1764,
+	1767,
+	1768,
+	1771,
+	1772,
+	1840,
+	1842,
+	1843,
+	1845,
+	1846,
+	1850,
+	1853,
+	1855,
+	1856,
+	1857,
+	1859,
+	1861,
+	1863,
+	1865,
+	1866,
+	2027,
+	2028,
+	2029,
+	2030,
+	2031,
+	2032,
+	2033,
+	2035,
+	2070,
+	2071,
+	2072,
+	2073,
+	2075,
+	2076,
+	2077,
+	2078,
+	2079,
+	2080,
+	2081,
+	2082,
+	2083,
+	2085,
+	2086,
+	2087,
+	2089,
+	2090,
+	2091,
+	2092,
+	2093,
+	2385,
+	2387,
+	2388,
+	3970,
+	3971,
+	3974,
+	3975,
+	4957,
+	4958,
+	4959,
+	6109,
+	6458,
+	6679,
+	6773,
+	6774,
+	6775,
+	6776,
+	6777,
+	6778,
+	6779,
+	6780,
+	7019,
+	7021,
+	7022,
+	7023,
+	7024,
+	7025,
+	7026,
+	7027,
+	7376,
+	7377,
+	7378,
+	7386,
+	7387,
+	7392,
+	7616,
+	7617,
+	7619,
+	7620,
+	7621,
+	7622,
+	7623,
+	7624,
+	7625,
+	7627,
+	7628,
+	7633,
+	7634,
+	7635,
+	7636,
+	7637,
+	7638,
+	7639,
+	7640,
+	7641,
+	7642,
+	7643,
+	7644,
+	7645,
+	7646,
+	7647,
+	7648,
+	7649,
+	7650,
+	7651,
+	7652,
+	7653,
+	7654,
+	7678,
+	8400,
+	8401,
+	8404,
+	8405,
+	8406,
+	8407,
+	8411,
+	8412,
+	8417,
+	8423,
+	8425,
+	8432,
+	11503,
+	11504,
+	11505,
+	11744,
+	11745,
+	11746,
+	11747,
+	11748,
+	11749,
+	11750,
+	11751,
+	11752,
+	11753,
+	11754,
+	11755,
+	11756,
+	11757,
+	11758,
+	11759,
+	11760,
+	11761,
+	11762,
+	11763,
+	11764,
+	11765,
+	11766,
+	11767,
+	11768,
+	11769,
+	11770,
+	11771,
+	11772,
+	11773,
+	11774,
+	11775,
+	42607,
+	42620,
+	42621,
+	42736,
+	42737,
+	43232,
+	43233,
+	43234,
+	43235,
+	43236,
+	43237,
+	43238,
+	43239,
+	43240,
+	43241,
+	43242,
+	43243,
+	43244,
+	43245,
+	43246,
+	43247,
+	43248,
+	43249,
+	43696,
+	43698,
+	43699,
+	43703,
+	43704,
+	43710,
+	43711,
+	43713,
+	65056,
+	65057,
+	65058,
+	65059,
+	65060,
+	65061,
+	65062,
+	68111,
+	68152,
+	119173,
+	119174,
+	119175,
+	119176,
+	119177,
+	119210,
+	119211,
+	119212,
+	119213,
+	119362,
+	119363,
+	119364
+].map((c) => String.fromCodePoint(c));
+const PLACEHOLDER = String.fromCodePoint(1109742);
+const CHUNK_SIZE = 4096;
+const transmitCache = /* @__PURE__ */ new Map();
+const known = {
+	ghostty: { inline: true },
+	kitty: { inline: true },
+	rio: { inline: false },
+	wezterm: { inline: false }
+};
+let prom = void 0;
+let kitty = void 0;
+const wrapTmux = (seq) => `\x1bPtmux;${seq.replaceAll("\x1B", "\x1B\x1B")}\x1b\\`;
+/** Allocate a fresh 24-bit image id (1..0xFFFFFFFE). */
+function allocateImageId() {
+	return Math.floor(Math.random() * 16777213) + 1;
+}
+/** Allocate a fresh 24-bit placement id. */
+function allocatePlacementId() {
+	return Math.floor(Math.random() * 16777213) + 1;
+}
+var Kitty = class {
+	#support;
+	#wrap = (s) => s;
+	constructor(support) {
+		this.#support = support;
+		this.#wrap = support.wrap ?? ((s) => s);
+	}
+	get supported() {
+		return this.#support.ok;
+	}
+	get inline() {
+		return this.#support.ok && this.#support.inline === true;
+	}
+	/** Create a KGP request escape sequence */
+	request(attrs, data, opts = {}) {
+		const params = Object.entries(attrs).map(([k, v]) => `${k}=${v}`).join(",");
+		let encoded;
+		if (opts.base64 === false && typeof data === "string") encoded = data;
+		else if (data) encoded = toBase64(typeof data === "string" ? new TextEncoder().encode(data) : data);
+		const payload = encoded ? `;${encoded}` : "";
+		return this.#wrap(`\x1b_G${params}${payload}\x1b\\`);
+	}
+	/** Create a TerminalQuery that requests a KGP operation and parses the response. */
+	query(attrs, data, opts = {}) {
+		return {
+			match: (ev) => {
+				if (ev.kind !== "apc") return;
+				const kr = this.parse(ev.sequence);
+				if (!kr) return;
+				return {
+					...ev,
+					...kr
+				};
+			},
+			request: this.request(attrs, data, opts)
+		};
+	}
+	/** Probe the terminal for KGP support. Should return an error response. */
+	probe() {
+		return this.request({
+			i: 4294967290,
+			s: 10,
+			t: "s",
+			v: 2
+		}, "<error>");
+	}
+	/** Parse a KGP response escape sequence into a structured object. */
+	parse(res) {
+		if (!res.startsWith("\x1B_G") || !res.endsWith("\x1B\\")) return void 0;
+		const m = res.slice(3, -2).match(/^([^;]+);(.*)?$/);
+		if (!m) return void 0;
+		const [_, params, data] = m;
+		const attrs = {};
+		for (const pair of params.split(",")) {
+			const [k, v] = pair.split("=", 2);
+			if (k && v) attrs[k] = /^\d+$/.test(v) ? parseInt(v, 10) : v;
+		}
+		if (data === "OK") return {
+			attrs,
+			ok: true
+		};
+		const error = data?.match(/^([A-Z]+):\s*(.*)$/);
+		return {
+			attrs,
+			error: error ? {
+				code: error[1],
+				message: error[2]
+			} : {
+				code: "UNKNOWN",
+				message: data ?? ""
+			},
+			ok: false
+		};
+	}
+	placement(imageId, dims) {
+		if (!this.#support.ok) return;
+		if (this.#support.inline) return {
+			data: unicodePlaceholder(imageId, dims),
+			imageId,
+			inline: true,
+			seq: this.request({
+				U: 1,
+				a: "p",
+				c: dims.cols,
+				i: imageId,
+				q: 2,
+				r: dims.rows
+			})
+		};
+		const blank = " ".repeat(dims.cols);
+		const placementId = allocatePlacementId();
+		const seq = this.request({
+			a: "p",
+			i: imageId,
+			p: placementId,
+			C: 1,
+			c: dims.cols,
+			q: 2,
+			r: dims.rows
+		});
+		return {
+			data: Array.from({ length: dims.rows }).fill(blank),
+			imageId,
+			placementId,
+			seq
+		};
+	}
+	/** Delete an image and all its placements, or ALL images if `imageId` is omitted. */
+	deleteImage(imageId) {
+		return imageId === void 0 ? this.request({
+			a: "d",
+			d: "A",
+			q: 2
+		}) : this.request({
+			a: "d",
+			d: "I",
+			i: imageId,
+			q: 2
+		});
+	}
+	/** Delete a placement (keeps image data so it can be re-placed cheaply). */
+	deletePlacement(imageId, placementId) {
+		return this.request({
+			a: "d",
+			d: "i",
+			i: imageId,
+			p: placementId,
+			q: 2
+		});
+	}
+	/**
+	* Ensure an image has been transmitted to the terminal at least once.
+	* On the first call per `src`, returns the full `a=t,t=f` escape to be
+	* prepended to the caller's first row — the APC payload has zero display
+	* width, so layout sees through it. Subsequent calls return `transmit:
+	* ""` since the terminal already has the bytes under `imageId`.
+	*
+	* The caller is expected to combine this with `placement(...)` on every
+	* render to actually paint the image at the right cell rectangle.
+	*/
+	async transmitOnce(info) {
+		if (!this.#support.ok) return void 0;
+		const { fileHash } = await import("@zaly/shared/detect");
+		const key = fileHash(info);
+		let entry = transmitCache.get(key);
+		if (entry === void 0) {
+			const { imageConvert } = await import("@zaly/shared/image");
+			const png = await imageConvert(info, "png");
+			if (!png) return void 0;
+			const id = allocateImageId();
+			entry = {
+				imageId: id,
+				sent: false,
+				seq: this.#support.remote || !png.path ? this.transmitBytes(id, png.data) : this.transmitFile(id, png.path)
+			};
+			transmitCache.set(key, entry);
+		}
+		if (entry.sent) {
+			entry.seq = "";
+			return { imageId: entry.imageId };
+		}
+		entry.sent = true;
+		return {
+			imageId: entry.imageId,
+			transmit: entry.seq
+		};
+	}
+	/**
+	* Transmit an image to the terminal by file path (`t=f`). Near-zero cost
+	* on the wire — the terminal opens and reads the file itself. `path`
+	* must be absolute and must point to a regular file; symlinks are
+	* followed by the terminal.
+	*/
+	transmitFile(id, path) {
+		return this.request({
+			a: "t",
+			f: 100,
+			i: id,
+			q: 2,
+			t: "f"
+		}, path);
+	}
+	/**
+	* Remote/bytes transmission fallback (`t=d`) for when the terminal can't
+	* read local files — typical of SSH sessions. Base64-encodes and chunks
+	* the PNG payload at 4KB boundaries per the protocol.
+	*/
+	transmitBytes(id, png) {
+		const base64 = toBase64(png);
+		const params = {
+			a: "t",
+			f: 100,
+			i: id,
+			q: 2,
+			t: "d"
+		};
+		if (base64.length <= CHUNK_SIZE) return this.request(params, base64, { base64: false });
+		const out = [];
+		let offset = 0;
+		let first = true;
+		while (offset < base64.length) {
+			const chunk = base64.slice(offset, offset + CHUNK_SIZE);
+			offset += CHUNK_SIZE;
+			const more = offset < base64.length ? 1 : 0;
+			out.push(this.request(first ? {
+				...params,
+				m: more
+			} : { m: more }, chunk, { base64: false }));
+			first = false;
+		}
+		return out.join("");
+	}
+};
+/** Drop the per-src transmit cache. Mostly for tests. */
+function resetTransmitCache() {
+	transmitCache.clear();
+}
+function resetKittyGraphics() {
+	resetTransmitCache();
+	prom = void 0;
+	kitty = void 0;
+}
+function intToRgb(color24bit) {
+	const r = color24bit >> 16 & 255;
+	const g = color24bit >> 8 & 255;
+	return {
+		b: color24bit & 255,
+		g,
+		r
+	};
+}
+function unicodePlaceholder(id, dims) {
+	const rgb = intToRgb(id);
+	const rows = Math.min(DIACRITICS.length, dims.rows);
+	const cols = Math.min(DIACRITICS.length, dims.cols);
+	const fg = `\x1b[38;2;${rgb.r};${rgb.g};${rgb.b}m`;
+	const img = [];
+	for (let r = 0; r < rows; r++) {
+		const line = [];
+		for (let c = 0; c < cols; c++) {
+			line.push(fg);
+			line.push(PLACEHOLDER);
+			line.push(DIACRITICS[r]);
+			line.push(DIACRITICS[c]);
+		}
+		line.push("\x1B[39m");
+		img.push(line.join(""));
+	}
+	return img;
+}
+function toBase64(bytes) {
+	if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
+	let binary = "";
+	for (const b of bytes) binary += String.fromCharCode(b);
+	return btoa(binary);
+}
+function bumpPlacements(rows) {
+	if (!kitty || kitty.inline) return;
+	const placements = [];
+	const ret = rows.map((row) => row.replace(/\x1b_Ga=p,i=(\d+),p=(\d+)/g, (_, i) => {
+		const imageId = parseInt(i, 10);
+		const placementId = allocatePlacementId();
+		placements.push({
+			i: imageId,
+			p: placementId
+		});
+		return `\x1b_Ga=p,i=${imageId},p=${placementId}`;
+	}));
+	if (!placements.length) return;
+	const k = kitty;
+	return {
+		delete: () => placements.map((p) => k.deletePlacement(p.i, p.p)).join(""),
+		rows: ret
+	};
+}
+async function detect(tq) {
+	const support = {
+		remote: isSSH,
+		tmux: !!process.env.TMUX,
+		wrap: process.env.TMUX ? wrapTmux : void 0
+	};
+	if (support.tmux) try {
+		const { spawnCmd } = await import("@zaly/shared/process");
+		await spawnCmd("tmux", "set", "-p", "allow-passthrough", "on");
+		support.wrap = wrapTmux;
+	} catch (error) {
+		return {
+			...support,
+			error: `Failed to set allow-passthrough in tmux: ${error instanceof Error ? error.message : String(error)}`,
+			ok: false
+		};
+	}
+	const v = await tq.xtVersion({ wrap: support.wrap });
+	if (!v) return {
+		error: "Failed to query terminal name & version",
+		ok: false,
+		...support
+	};
+	support.terminal = {
+		name: v.name,
+		version: v.version
+	};
+	const kgp = known[v.name.toLowerCase()];
+	if (kgp === false) return {
+		error: `Terminal ${v.name} does not support KGP`,
+		ok: false,
+		...support
+	};
+	if (kgp === void 0) {
+		const k = new Kitty({
+			...support,
+			error: "",
+			ok: false
+		});
+		if ((await tq.query({
+			match: (ev) => {
+				if (ev.kind === "apc" && ev.payload.startsWith("G")) return {
+					kgp: true,
+					...ev
+				};
+				if (ev.kind === "csi" && ev.final === "c" && ev.params.startsWith("?")) return {
+					kgp: false,
+					...ev
+				};
+			},
+			request: `${k.probe()}\x1b[c`,
+			timeout: 200
+		}))?.kgp !== true) return {
+			error: "Failed to query kitty graphics protocol",
+			ok: false,
+			...support
+		};
+	}
+	return {
+		...support,
+		inline: kgp?.inline,
+		ok: true,
+		terminal: {
+			name: v.name,
+			version: v.version
+		}
+	};
+}
+function loadKittyGraphics(tq) {
+	if (kitty) return kitty;
+	prom ??= (async () => kitty = new Kitty(await detect(tq)))();
+	return prom;
+}
+//#endregion
+export { allocatePlacementId as a, resetKittyGraphics as c, allocateImageId as i, resetTransmitCache as l, Kitty as n, bumpPlacements as o, PLACEHOLDER as r, loadKittyGraphics as s, DIACRITICS as t };
+
+//# sourceMappingURL=kitty-JbCJC0iQ.mjs.map