vt220.js 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -0,0 +1,756 @@
+//#region src/screen.ts
+/** Frozen sentinel for unwritten cells — never mutate, copy-on-write in writeChar(). */
+const EMPTY_CELL = Object.freeze({
+	char: "",
+	fg: null,
+	bg: null,
+	bold: false,
+	underline: false,
+	blink: false,
+	inverse: false,
+	hidden: false
+});
+function emptyCell() {
+	return { ...EMPTY_CELL };
+}
+const ANSI_8 = [
+	{
+		r: 0,
+		g: 0,
+		b: 0
+	},
+	{
+		r: 128,
+		g: 0,
+		b: 0
+	},
+	{
+		r: 0,
+		g: 128,
+		b: 0
+	},
+	{
+		r: 128,
+		g: 128,
+		b: 0
+	},
+	{
+		r: 0,
+		g: 0,
+		b: 128
+	},
+	{
+		r: 128,
+		g: 0,
+		b: 128
+	},
+	{
+		r: 0,
+		g: 128,
+		b: 128
+	},
+	{
+		r: 192,
+		g: 192,
+		b: 192
+	}
+];
+function createScreen(opts) {
+	let cols = opts.cols;
+	let rows = opts.rows;
+	const scrollbackLimit = opts.scrollbackLimit ?? 1e3;
+	const onResponse = opts.onResponse;
+	let grid = makeGrid(cols, rows);
+	let scrollback = [];
+	let curX = 0;
+	let curY = 0;
+	let curVisible = true;
+	let savedCurX = 0;
+	let savedCurY = 0;
+	let savedState = {
+		curX: 0,
+		curY: 0,
+		attrs: resetAttrs(),
+		originMode: false,
+		autoWrap: true
+	};
+	let attrs = resetAttrs();
+	let title = "";
+	let applicationCursor = false;
+	let applicationKeypad = false;
+	let autoWrap = true;
+	let originMode = false;
+	let insertMode = false;
+	let reverseVideo = false;
+	let scrollTop = 0;
+	let scrollBottom = rows - 1;
+	let viewportOffset = 0;
+	let parserState = "ground";
+	let escBuf = "";
+	let oscBuf = "";
+	const decoder = new TextDecoder();
+	function makeGrid(c, r) {
+		const g = [];
+		for (let row = 0; row < r; row++) g.push(makeRow(c));
+		return g;
+	}
+	function makeRow(c) {
+		const row = [];
+		for (let col = 0; col < c; col++) row.push(EMPTY_CELL);
+		return row;
+	}
+	function resetAttrs() {
+		return {
+			fg: null,
+			bg: null,
+			bold: false,
+			underline: false,
+			blink: false,
+			inverse: false,
+			hidden: false
+		};
+	}
+	function clampCursor() {
+		if (curX < 0) curX = 0;
+		if (curX >= cols) curX = cols - 1;
+		if (curY < 0) curY = 0;
+		if (curY >= rows) curY = rows - 1;
+	}
+	function scrollUp(top, bottom) {
+		if (top === 0) {
+			scrollback.push(grid[0]);
+			if (scrollback.length > scrollbackLimit * 2) scrollback.splice(0, scrollback.length - scrollbackLimit);
+		}
+		for (let i = top; i < bottom; i++) grid[i] = grid[i + 1];
+		grid[bottom] = makeRow(cols);
+	}
+	function scrollDown(top, bottom) {
+		for (let i = bottom; i > top; i--) grid[i] = grid[i - 1];
+		grid[top] = makeRow(cols);
+	}
+	function writeChar(ch) {
+		if (curX >= cols) if (autoWrap) {
+			curX = 0;
+			curY++;
+			if (curY > scrollBottom) {
+				curY = scrollBottom;
+				scrollUp(scrollTop, scrollBottom);
+			}
+		} else curX = cols - 1;
+		if (insertMode) {
+			const row = grid[curY];
+			row.splice(curX, 0, EMPTY_CELL);
+			row.pop();
+		}
+		const row = grid[curY];
+		let cell = row[curX];
+		if (cell === EMPTY_CELL) {
+			cell = { ...EMPTY_CELL };
+			row[curX] = cell;
+		}
+		cell.char = ch;
+		cell.fg = attrs.fg ? { ...attrs.fg } : null;
+		cell.bg = attrs.bg ? { ...attrs.bg } : null;
+		cell.bold = attrs.bold;
+		cell.underline = attrs.underline;
+		cell.blink = attrs.blink;
+		cell.inverse = attrs.inverse;
+		cell.hidden = attrs.hidden;
+		curX++;
+	}
+	function handleCSI(params, finalByte) {
+		const parts = params.split(";").map((s) => s === "" ? 0 : parseInt(s, 10));
+		switch (finalByte) {
+			case "A":
+				curY -= Math.max(parts[0] ?? 1, 1);
+				clampCursor();
+				break;
+			case "B":
+				curY += Math.max(parts[0] ?? 1, 1);
+				clampCursor();
+				break;
+			case "C":
+				curX += Math.max(parts[0] ?? 1, 1);
+				clampCursor();
+				break;
+			case "D":
+				curX -= Math.max(parts[0] ?? 1, 1);
+				clampCursor();
+				break;
+			case "E":
+				curY += Math.max(parts[0] ?? 1, 1);
+				curX = 0;
+				clampCursor();
+				break;
+			case "F":
+				curY -= Math.max(parts[0] ?? 1, 1);
+				curX = 0;
+				clampCursor();
+				break;
+			case "G":
+				curX = (parts[0] ?? 1) - 1;
+				clampCursor();
+				break;
+			case "H":
+			case "f":
+				curY = (parts[0] ?? 1) - 1;
+				curX = (parts[1] ?? 1) - 1;
+				clampCursor();
+				break;
+			case "J":
+				handleEraseDisplay(parts[0] ?? 0);
+				break;
+			case "K":
+				handleEraseLine(parts[0] ?? 0);
+				break;
+			case "L":
+				handleInsertLines(Math.max(parts[0] ?? 1, 1));
+				break;
+			case "M":
+				handleDeleteLines(Math.max(parts[0] ?? 1, 1));
+				break;
+			case "P":
+				handleDeleteChars(Math.max(parts[0] ?? 1, 1));
+				break;
+			case "@":
+				handleInsertChars(Math.max(parts[0] ?? 1, 1));
+				break;
+			case "X":
+				handleEraseChars(Math.max(parts[0] ?? 1, 1));
+				break;
+			case "S":
+				for (let i = 0; i < Math.max(parts[0] ?? 1, 1); i++) scrollUp(scrollTop, scrollBottom);
+				break;
+			case "T":
+				for (let i = 0; i < Math.max(parts[0] ?? 1, 1); i++) scrollDown(scrollTop, scrollBottom);
+				break;
+			case "d":
+				curY = (parts[0] ?? 1) - 1;
+				clampCursor();
+				break;
+			case "m":
+				handleSGR(params);
+				break;
+			case "r":
+				scrollTop = (parts[0] ?? 1) - 1;
+				scrollBottom = (parts[1] ?? rows) - 1;
+				if (scrollTop < 0) scrollTop = 0;
+				if (scrollBottom >= rows) scrollBottom = rows - 1;
+				if (scrollTop > scrollBottom) {
+					scrollTop = 0;
+					scrollBottom = rows - 1;
+				}
+				curX = 0;
+				curY = originMode ? scrollTop : 0;
+				break;
+			case "n":
+				if (onResponse) {
+					if (parts[0] === 5) onResponse("\x1B[0n");
+					else if (parts[0] === 6) onResponse(`\x1b[${curY + 1};${curX + 1}R`);
+				}
+				break;
+			case "c":
+				if (onResponse) {
+					if (params === "" || params === "0") onResponse("\x1B[?62;1;2;6;7;8;9c");
+				}
+				break;
+			case "s":
+				savedCurX = curX;
+				savedCurY = curY;
+				break;
+			case "u":
+				curX = savedCurX;
+				curY = savedCurY;
+				clampCursor();
+				break;
+			default: break;
+		}
+	}
+	function handleCSIWithIntermediate(params, intermediate, finalByte) {
+		if (intermediate === "!" && finalByte === "p") softReset();
+		else if (intermediate === ">" && finalByte === "c") {
+			if (onResponse) onResponse("\x1B[>1;10;0c");
+		}
+	}
+	function handleCSIPrivate(params, finalByte) {
+		const parts = params.split(";").map((s) => s === "" ? 0 : parseInt(s, 10));
+		if (finalByte === "J") {
+			handleSelectiveEraseDisplay(parts[0] ?? 0);
+			return;
+		}
+		if (finalByte === "K") {
+			handleSelectiveEraseLine(parts[0] ?? 0);
+			return;
+		}
+		const set = finalByte === "h";
+		for (const code of parts) switch (code) {
+			case 1:
+				applicationCursor = set;
+				break;
+			case 4:
+				insertMode = set;
+				break;
+			case 5:
+				reverseVideo = set;
+				break;
+			case 6:
+				originMode = set;
+				break;
+			case 7:
+				autoWrap = set;
+				break;
+			case 25:
+				curVisible = set;
+				break;
+			case 66:
+				applicationKeypad = set;
+				break;
+		}
+	}
+	function handleSetResetMode(params, finalByte) {
+		const parts = params.split(";").map((s) => s === "" ? 0 : parseInt(s, 10));
+		const set = finalByte === "h";
+		for (const code of parts) switch (code) {
+			case 4:
+				insertMode = set;
+				break;
+		}
+	}
+	function handleEraseDisplay(mode) {
+		switch (mode) {
+			case 0:
+				eraseCells(curY, curX, curY, cols - 1);
+				for (let row = curY + 1; row < rows; row++) eraseCells(row, 0, row, cols - 1);
+				break;
+			case 1:
+				for (let row = 0; row < curY; row++) eraseCells(row, 0, row, cols - 1);
+				eraseCells(curY, 0, curY, curX);
+				break;
+			case 2:
+			case 3:
+				for (let row = 0; row < rows; row++) eraseCells(row, 0, row, cols - 1);
+				if (mode === 3) scrollback.length = 0;
+				break;
+		}
+	}
+	function handleEraseLine(mode) {
+		switch (mode) {
+			case 0:
+				eraseCells(curY, curX, curY, cols - 1);
+				break;
+			case 1:
+				eraseCells(curY, 0, curY, curX);
+				break;
+			case 2:
+				eraseCells(curY, 0, curY, cols - 1);
+				break;
+		}
+	}
+	function handleSelectiveEraseDisplay(mode) {
+		handleEraseDisplay(mode);
+	}
+	function handleSelectiveEraseLine(mode) {
+		handleEraseLine(mode);
+	}
+	function eraseCells(row, startCol, _endRow, endCol) {
+		const r = grid[row];
+		if (!r) return;
+		for (let col = startCol; col <= endCol && col < cols; col++) r[col] = emptyCell();
+	}
+	function handleInsertLines(count) {
+		if (curY < scrollTop || curY > scrollBottom) return;
+		for (let i = 0; i < count; i++) scrollDown(curY, scrollBottom);
+	}
+	function handleDeleteLines(count) {
+		if (curY < scrollTop || curY > scrollBottom) return;
+		for (let i = 0; i < count; i++) scrollUp(curY, scrollBottom);
+	}
+	function handleDeleteChars(count) {
+		const row = grid[curY];
+		if (!row) return;
+		for (let i = 0; i < count; i++) if (curX < cols) {
+			row.splice(curX, 1);
+			row.push(emptyCell());
+		}
+	}
+	function handleInsertChars(count) {
+		const row = grid[curY];
+		if (!row) return;
+		for (let i = 0; i < count; i++) {
+			row.splice(curX, 0, emptyCell());
+			row.pop();
+		}
+	}
+	function handleEraseChars(count) {
+		const row = grid[curY];
+		if (!row) return;
+		for (let i = 0; i < count && curX + i < cols; i++) row[curX + i] = emptyCell();
+	}
+	function handleSGR(rawParams) {
+		const params = rawParams.split(";").map((s) => s === "" ? 0 : parseInt(s, 10));
+		if (params.length === 0 || params.length === 1 && params[0] === 0) {
+			attrs = resetAttrs();
+			return;
+		}
+		let i = 0;
+		while (i < params.length) {
+			const code = params[i];
+			switch (code) {
+				case 0:
+					attrs = resetAttrs();
+					break;
+				case 1:
+					attrs.bold = true;
+					break;
+				case 4:
+					attrs.underline = true;
+					break;
+				case 5:
+					attrs.blink = true;
+					break;
+				case 7:
+					attrs.inverse = true;
+					break;
+				case 8:
+					attrs.hidden = true;
+					break;
+				case 22:
+					attrs.bold = false;
+					break;
+				case 24:
+					attrs.underline = false;
+					break;
+				case 25:
+					attrs.blink = false;
+					break;
+				case 27:
+					attrs.inverse = false;
+					break;
+				case 28:
+					attrs.hidden = false;
+					break;
+				case 30:
+				case 31:
+				case 32:
+				case 33:
+				case 34:
+				case 35:
+				case 36:
+				case 37:
+					attrs.fg = { ...ANSI_8[code - 30] };
+					break;
+				case 39:
+					attrs.fg = null;
+					break;
+				case 40:
+				case 41:
+				case 42:
+				case 43:
+				case 44:
+				case 45:
+				case 46:
+				case 47:
+					attrs.bg = { ...ANSI_8[code - 40] };
+					break;
+				case 49:
+					attrs.bg = null;
+					break;
+				case 38:
+				case 48:
+					if (i + 1 < params.length && params[i + 1] === 2) i += 4;
+					else if (i + 1 < params.length && params[i + 1] === 5) i += 2;
+					break;
+			}
+			i++;
+		}
+	}
+	function handleOSC(oscString) {
+		const semicolonIdx = oscString.indexOf(";");
+		if (semicolonIdx === -1) return;
+		const code = parseInt(oscString.substring(0, semicolonIdx), 10);
+		const value = oscString.substring(semicolonIdx + 1);
+		switch (code) {
+			case 0:
+			case 2:
+				title = value;
+				break;
+			case 1: break;
+		}
+	}
+	function process(data) {
+		const text = decoder.decode(data, { stream: true });
+		for (let i = 0; i < text.length; i++) {
+			const ch = text[i];
+			const code = text.charCodeAt(i);
+			switch (parserState) {
+				case "ground":
+					if (code === 27) {
+						parserState = "escape";
+						escBuf = "";
+					} else if (code === 7) {} else if (code === 8) {
+						if (curX > 0) curX--;
+					} else if (code === 9) curX = Math.min((Math.floor(curX / 8) + 1) * 8, cols - 1);
+					else if (code === 10 || code === 11 || code === 12) {
+						curY++;
+						if (curY > scrollBottom) {
+							curY = scrollBottom;
+							scrollUp(scrollTop, scrollBottom);
+						}
+					} else if (code === 13) curX = 0;
+					else if (code >= 32) writeChar(ch);
+					break;
+				case "escape":
+					if (ch === "[") {
+						parserState = "csi";
+						escBuf = "";
+					} else if (ch === "]") {
+						parserState = "osc";
+						oscBuf = "";
+					} else if (ch === "P") {
+						parserState = "dcs";
+						escBuf = "";
+					} else if (ch === "c") fullReset();
+					else if (ch === "D") {
+						curY++;
+						if (curY > scrollBottom) {
+							curY = scrollBottom;
+							scrollUp(scrollTop, scrollBottom);
+						}
+						parserState = "ground";
+					} else if (ch === "M") {
+						curY--;
+						if (curY < scrollTop) {
+							curY = scrollTop;
+							scrollDown(scrollTop, scrollBottom);
+						}
+						parserState = "ground";
+					} else if (ch === "7") {
+						savedState = {
+							curX,
+							curY,
+							attrs: {
+								...attrs,
+								fg: attrs.fg ? { ...attrs.fg } : null,
+								bg: attrs.bg ? { ...attrs.bg } : null
+							},
+							originMode,
+							autoWrap
+						};
+						parserState = "ground";
+					} else if (ch === "8") {
+						curX = savedState.curX;
+						curY = savedState.curY;
+						attrs = {
+							...savedState.attrs,
+							fg: savedState.attrs.fg ? { ...savedState.attrs.fg } : null,
+							bg: savedState.attrs.bg ? { ...savedState.attrs.bg } : null
+						};
+						originMode = savedState.originMode;
+						autoWrap = savedState.autoWrap;
+						clampCursor();
+						parserState = "ground";
+					} else if (ch === "E") {
+						curX = 0;
+						curY++;
+						if (curY > scrollBottom) {
+							curY = scrollBottom;
+							scrollUp(scrollTop, scrollBottom);
+						}
+						parserState = "ground";
+					} else if (ch === "=") {
+						applicationKeypad = true;
+						parserState = "ground";
+					} else if (ch === ">") {
+						applicationKeypad = false;
+						parserState = "ground";
+					} else parserState = "ground";
+					break;
+				case "csi":
+					if (code >= 64 && code <= 126) {
+						if (escBuf.startsWith("?")) handleCSIPrivate(escBuf.substring(1), ch);
+						else if (ch === "h" || ch === "l") handleSetResetMode(escBuf, ch);
+						else {
+							let intermediateIdx = -1;
+							for (let j = 0; j < escBuf.length; j++) {
+								const c = escBuf.charCodeAt(j);
+								if (c >= 32 && c <= 47 || c === 62) {
+									intermediateIdx = j;
+									break;
+								}
+							}
+							if (intermediateIdx >= 0) handleCSIWithIntermediate(escBuf.substring(0, intermediateIdx), escBuf.substring(intermediateIdx), ch);
+							else handleCSI(escBuf, ch);
+						}
+						parserState = "ground";
+					} else if (escBuf.length >= 256) parserState = "ground";
+					else escBuf += ch;
+					break;
+				case "osc":
+					if (code === 7) {
+						handleOSC(oscBuf);
+						parserState = "ground";
+					} else if (code === 27) parserState = "oscString";
+					else if (oscBuf.length >= 4096) parserState = "ground";
+					else oscBuf += ch;
+					break;
+				case "oscString":
+					if (ch === "\\") handleOSC(oscBuf);
+					parserState = "ground";
+					break;
+				case "dcs":
+					if (code === 27) parserState = "oscString";
+					break;
+			}
+		}
+	}
+	function fullReset() {
+		grid = makeGrid(cols, rows);
+		scrollback = [];
+		curX = 0;
+		curY = 0;
+		curVisible = true;
+		savedCurX = 0;
+		savedCurY = 0;
+		savedState = {
+			curX: 0,
+			curY: 0,
+			attrs: resetAttrs(),
+			originMode: false,
+			autoWrap: true
+		};
+		attrs = resetAttrs();
+		title = "";
+		applicationCursor = false;
+		applicationKeypad = false;
+		autoWrap = true;
+		originMode = false;
+		insertMode = false;
+		reverseVideo = false;
+		scrollTop = 0;
+		scrollBottom = rows - 1;
+		viewportOffset = 0;
+		parserState = "ground";
+		escBuf = "";
+		oscBuf = "";
+	}
+	function softReset() {
+		attrs = resetAttrs();
+		applicationCursor = false;
+		applicationKeypad = false;
+		autoWrap = true;
+		originMode = false;
+		insertMode = false;
+		reverseVideo = false;
+		curVisible = true;
+		scrollTop = 0;
+		scrollBottom = rows - 1;
+		savedState = {
+			curX: 0,
+			curY: 0,
+			attrs: resetAttrs(),
+			originMode: false,
+			autoWrap: true
+		};
+		savedCurX = 0;
+		savedCurY = 0;
+	}
+	function resize(newCols, newRows) {
+		const newGrid = makeGrid(newCols, newRows);
+		copyGrid(grid, newGrid, Math.min(cols, newCols), Math.min(rows, newRows));
+		grid = newGrid;
+		cols = newCols;
+		rows = newRows;
+		scrollTop = 0;
+		scrollBottom = rows - 1;
+		clampCursor();
+	}
+	function copyGrid(src, dst, copyCols, copyRows) {
+		for (let row = 0; row < copyRows; row++) for (let col = 0; col < copyCols; col++) {
+			const srcCell = src[row]?.[col];
+			if (srcCell) dst[row][col] = { ...srcCell };
+		}
+	}
+	function getCell(row, col) {
+		const r = grid[row];
+		if (!r || col >= cols) return emptyCell();
+		return { ...r[col] };
+	}
+	function getLine(row) {
+		const r = grid[row];
+		if (!r) return makeRow(cols);
+		return r.map((cell) => ({ ...cell }));
+	}
+	function getText() {
+		const lines = [];
+		for (const row of scrollback) lines.push(rowToString(row));
+		for (let r = 0; r < rows; r++) lines.push(rowToString(grid[r]));
+		return lines.join("\n");
+	}
+	function rowToString(row) {
+		let line = "";
+		for (let i = 0; i < row.length; i++) {
+			const cell = row[i];
+			if (cell.char === "") line += " ";
+			else line += cell.char;
+		}
+		return line.replace(/\s+$/, "");
+	}
+	function getTextRange(startRow, startCol, endRow, endCol) {
+		const parts = [];
+		for (let row = startRow; row <= endRow; row++) {
+			const r = grid[row];
+			if (!r) continue;
+			const colStart = row === startRow ? startCol : 0;
+			const colEnd = row === endRow ? endCol : cols;
+			let line = "";
+			for (let col = colStart; col < colEnd; col++) {
+				const cell = r[col];
+				if (!cell) continue;
+				line += cell.char || " ";
+			}
+			parts.push(line.replace(/\s+$/, ""));
+		}
+		return parts.join("\n");
+	}
+	function getMode(mode) {
+		switch (mode) {
+			case "cursorVisible": return curVisible;
+			case "applicationCursor": return applicationCursor;
+			case "applicationKeypad": return applicationKeypad;
+			case "autoWrap": return autoWrap;
+			case "originMode": return originMode;
+			case "insertMode": return insertMode;
+			case "reverseVideo": return reverseVideo;
+			default: return false;
+		}
+	}
+	return {
+		get cols() {
+			return cols;
+		},
+		get rows() {
+			return rows;
+		},
+		process,
+		resize,
+		reset: fullReset,
+		getCell,
+		getLine,
+		getText,
+		getTextRange,
+		getCursorPosition: () => ({
+			x: curX,
+			y: curY
+		}),
+		getCursorVisible: () => curVisible,
+		getTitle: () => title,
+		getMode,
+		getScrollbackLength: () => scrollback.length,
+		getViewportOffset: () => viewportOffset,
+		scrollViewport: (delta) => {
+			viewportOffset = Math.max(0, Math.min(scrollback.length, viewportOffset + delta));
+		}
+	};
+}
+//#endregion
+export { createScreen as createVt220Screen };