739 lines
30 KiB
TypeScript
739 lines
30 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
||
|
||
const {
|
||
ANSI_RESET_STATE,
|
||
applyTerminalOutput,
|
||
cloneTerminalBufferState,
|
||
getActiveTerminalBuffer,
|
||
rebuildTerminalBufferStateFromReplayText,
|
||
trimTerminalReplayTextToMaxBytes
|
||
} = require("./terminalBufferState.js");
|
||
const { lineCellsToText } = require("./terminalCursorModel.js");
|
||
const { takeTerminalReplaySlice } = require("./vtParser.js");
|
||
|
||
describe("terminalBufferState", () => {
|
||
it("宽字符和组合字符仍按 cell 列推进，不回退到字符串长度语义", () => {
|
||
const result = applyTerminalOutput(
|
||
{
|
||
cells: [[]],
|
||
ansiState: { ...ANSI_RESET_STATE },
|
||
cursorRow: 0,
|
||
cursorCol: 0
|
||
},
|
||
"中e\u0301A",
|
||
{ bufferCols: 10, maxEntries: 20, maxBytes: 1024 }
|
||
);
|
||
|
||
const row = result.state.cells[0];
|
||
expect(lineCellsToText(row)).toBe("中e\u0301A");
|
||
expect(result.state.cursorRow).toBe(0);
|
||
expect(result.state.cursorCol).toBe(4);
|
||
expect(row[0]).toMatchObject({ text: "中", width: 2, continuation: false });
|
||
expect(row[1]).toMatchObject({ text: "", width: 0, continuation: true });
|
||
expect(row[2]).toMatchObject({ text: "e\u0301", width: 1, continuation: false });
|
||
expect(row[3]).toMatchObject({ text: "A", width: 1, continuation: false });
|
||
});
|
||
|
||
it("覆盖宽字符 continuation 时会先清理 owner，避免留下脏半格", () => {
|
||
const result = applyTerminalOutput(
|
||
{
|
||
cells: [[]],
|
||
ansiState: { ...ANSI_RESET_STATE },
|
||
cursorRow: 0,
|
||
cursorCol: 0
|
||
},
|
||
"中\bA",
|
||
{ bufferCols: 10, maxEntries: 20, maxBytes: 1024 }
|
||
);
|
||
|
||
const row = result.state.cells[0];
|
||
expect(lineCellsToText(row)).toBe(" A");
|
||
expect(result.state.cursorCol).toBe(2);
|
||
expect(row[0]).toMatchObject({ text: "", width: 1, continuation: false, placeholder: true });
|
||
expect(row[1]).toMatchObject({ text: "A", width: 1, continuation: false });
|
||
expect(row.some((cell: { continuation?: boolean }) => !!cell && !!cell.continuation)).toBe(false);
|
||
});
|
||
|
||
it("在列数变化后可按重放文本重新排布旧输出", () => {
|
||
const narrowResult = applyTerminalOutput(
|
||
{
|
||
cells: [[]],
|
||
ansiState: { ...ANSI_RESET_STATE },
|
||
cursorRow: 0,
|
||
cursorCol: 0
|
||
},
|
||
"abcdef",
|
||
{ bufferCols: 4, maxEntries: 20, maxBytes: 1024 }
|
||
);
|
||
const replayState = rebuildTerminalBufferStateFromReplayText(narrowResult.cleanText, {
|
||
bufferCols: 8,
|
||
maxEntries: 20,
|
||
maxBytes: 1024
|
||
});
|
||
|
||
expect(narrowResult.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["abcd", "ef"]);
|
||
expect(replayState.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["abcdef"]);
|
||
expect(replayState.cursorRow).toBe(0);
|
||
expect(replayState.cursorCol).toBe(6);
|
||
});
|
||
|
||
it("重放文本会保留 ANSI 清行后的最终屏幕状态", () => {
|
||
const result = applyTerminalOutput(
|
||
{
|
||
cells: [[]],
|
||
ansiState: { ...ANSI_RESET_STATE },
|
||
cursorRow: 0,
|
||
cursorCol: 0
|
||
},
|
||
"hello\r\u001b[0Kworld",
|
||
{ bufferCols: 10, maxEntries: 20, maxBytes: 1024 }
|
||
);
|
||
const replayState = rebuildTerminalBufferStateFromReplayText(result.cleanText, {
|
||
bufferCols: 10,
|
||
maxEntries: 20,
|
||
maxBytes: 1024
|
||
});
|
||
|
||
expect(replayState.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["world"]);
|
||
expect(replayState.cursorCol).toBe(5);
|
||
});
|
||
|
||
it("快照裁剪时保留尾部重放文本，便于恢复后按新列宽重建", () => {
|
||
expect(trimTerminalReplayTextToMaxBytes("ab中cd", 5)).toBe("中cd");
|
||
expect(trimTerminalReplayTextToMaxBytes("abcd", 8)).toBe("abcd");
|
||
});
|
||
|
||
it("宽字符输出在列数变化后仍可按 replay 文本重建", () => {
|
||
const narrowResult = applyTerminalOutput(
|
||
{
|
||
cells: [[]],
|
||
ansiState: { ...ANSI_RESET_STATE },
|
||
cursorRow: 0,
|
||
cursorCol: 0
|
||
},
|
||
"中AB",
|
||
{ bufferCols: 3, maxEntries: 20, maxBytes: 1024 }
|
||
);
|
||
const replayState = rebuildTerminalBufferStateFromReplayText(narrowResult.cleanText, {
|
||
bufferCols: 4,
|
||
maxEntries: 20,
|
||
maxBytes: 1024
|
||
});
|
||
|
||
expect(narrowResult.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["中A", "B"]);
|
||
expect(replayState.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["中AB"]);
|
||
expect(replayState.cursorRow).toBe(0);
|
||
expect(replayState.cursorCol).toBe(4);
|
||
});
|
||
|
||
it("按安全切片连续推进后，最终终端状态应与整段推进一致", () => {
|
||
const options = { bufferCols: 10, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const source = "ab\r\n\u001b[31mcd\u001b[0mZ";
|
||
const whole = applyTerminalOutput(createEmptyState(), source, options);
|
||
|
||
let remaining = source;
|
||
let state = createEmptyState();
|
||
while (remaining) {
|
||
const part = takeTerminalReplaySlice(remaining, 4);
|
||
expect(part.slice.length).toBeGreaterThan(0);
|
||
const partial = applyTerminalOutput(state, part.slice, options);
|
||
state = partial.state;
|
||
remaining = part.rest;
|
||
}
|
||
|
||
expect(state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(
|
||
whole.state.cells.map((row: unknown[]) => lineCellsToText(row))
|
||
);
|
||
expect(state.cursorRow).toBe(whole.state.cursorRow);
|
||
expect(state.cursorCol).toBe(whole.state.cursorCol);
|
||
expect(state.ansiState).toEqual(whole.state.ansiState);
|
||
});
|
||
|
||
it("stdout 运行态复用时，最终状态应与常规不可变推进一致", () => {
|
||
const options = { bufferCols: 10, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const base = applyTerminalOutput(createEmptyState(), "ab\r\ncd", options);
|
||
const regularBase = cloneTerminalBufferState(base.state, options);
|
||
const runtimeBase = cloneTerminalBufferState(base.state, options, { cloneRows: false });
|
||
const regular = applyTerminalOutput(regularBase, "\u001b[31mZ", options);
|
||
const reused = applyTerminalOutput(runtimeBase, "\u001b[31mZ", options, {
|
||
reuseState: true,
|
||
reuseRows: true
|
||
});
|
||
|
||
expect(reused.state).toBe(runtimeBase);
|
||
expect(reused.state.cells).toBe(reused.state.buffers.normal.cells);
|
||
expect(reused.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(
|
||
regular.state.cells.map((row: unknown[]) => lineCellsToText(row))
|
||
);
|
||
expect(reused.state.cursorRow).toBe(regular.state.cursorRow);
|
||
expect(reused.state.cursorCol).toBe(regular.state.cursorCol);
|
||
expect(reused.state.ansiState).toEqual(regular.state.ansiState);
|
||
});
|
||
|
||
it("1049 alt screen 切换后会保留 normal buffer 历史，并在退出时恢复", () => {
|
||
const options = { bufferCols: 10, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const base = applyTerminalOutput(createEmptyState(), "shell>", options);
|
||
const entered = applyTerminalOutput(base.state, "\u001b[?1049hTOP", options);
|
||
const restored = applyTerminalOutput(entered.state, "\u001b[?1049l", options);
|
||
|
||
expect(getActiveTerminalBuffer(entered.state).isAlt).toBe(true);
|
||
expect(entered.state.activeBufferName).toBe("alt");
|
||
expect(entered.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["TOP", "", "", ""]);
|
||
expect(restored.state.activeBufferName).toBe("normal");
|
||
expect(restored.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["shell>"]);
|
||
});
|
||
|
||
it("私有模式会驱动 Codex 依赖的关键终端模式位", () => {
|
||
const options = { bufferCols: 10, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const hidden = applyTerminalOutput(
|
||
createEmptyState(),
|
||
"\u001b[?25l\u001b[?1h\u001b[?45h\u001b[?66h\u001b[?1004h\u001b[?2004h\u001b[4h",
|
||
options
|
||
);
|
||
const shown = applyTerminalOutput(
|
||
hidden.state,
|
||
"\u001b[?25h\u001b[?1l\u001b[?45l\u001b[?66l\u001b[?1004l\u001b[?2004l\u001b[4l",
|
||
options
|
||
);
|
||
|
||
expect(hidden.state.modes).toMatchObject({
|
||
cursorHidden: true,
|
||
applicationCursorKeys: true,
|
||
applicationKeypad: true,
|
||
reverseWraparound: true,
|
||
sendFocus: true,
|
||
bracketedPasteMode: true,
|
||
insertMode: true
|
||
});
|
||
expect(shown.state.modes).toMatchObject({
|
||
cursorHidden: false,
|
||
applicationCursorKeys: false,
|
||
applicationKeypad: false,
|
||
reverseWraparound: false,
|
||
sendFocus: false,
|
||
bracketedPasteMode: false,
|
||
insertMode: false
|
||
});
|
||
});
|
||
|
||
it("DSR/CPR 查询会生成响应，而不会污染屏幕内容", () => {
|
||
const options = { bufferCols: 10, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const result = applyTerminalOutput(createEmptyState(), "ab\u001b[6n\u001b[5n", options);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["ab"]);
|
||
expect(result.responses).toEqual(["\u001b[1;3R", "\u001b[0n"]);
|
||
});
|
||
|
||
it("DA1/DA2 查询会分别返回 primary 和 secondary device attributes", () => {
|
||
const options = { bufferCols: 10, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const result = applyTerminalOutput(createEmptyState(), "\u001b[c\u001b[>c", options);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([""]);
|
||
expect(result.responses).toEqual(["\u001b[?1;2c", "\u001b[>0;276;0c"]);
|
||
});
|
||
|
||
it("OSC 10/11/12 颜色查询会返回最小可用响应，而不会污染屏幕内容", () => {
|
||
const options = { bufferCols: 10, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const result = applyTerminalOutput(
|
||
createEmptyState(),
|
||
"\u001b]10;?\u001b\\\u001b]11;?\u001b\\\u001b]12;?\u001b\\",
|
||
options,
|
||
{
|
||
defaultForeground: "#112233",
|
||
defaultBackground: "#445566",
|
||
defaultCursor: "#778899"
|
||
}
|
||
);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([""]);
|
||
expect(result.responses).toEqual([
|
||
"\u001b]10;rgb:1111/2222/3333\u001b\\",
|
||
"\u001b]11;rgb:4444/5555/6666\u001b\\",
|
||
"\u001b]12;rgb:7777/8888/9999\u001b\\"
|
||
]);
|
||
});
|
||
|
||
it("normal buffer 的绝对定位会以当前可视尾部为基准，而不是写回历史顶部", () => {
|
||
const options = { bufferCols: 10, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const base = applyTerminalOutput(createEmptyState(), "1\r\n2\r\n3\r\n4\r\n5", options);
|
||
const result = applyTerminalOutput(base.state, "\u001b[1;1HX", options);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([
|
||
"1",
|
||
"X",
|
||
"3",
|
||
"4",
|
||
"5"
|
||
]);
|
||
expect(result.responses).toEqual([]);
|
||
});
|
||
|
||
it("CSI B 在 normal buffer 中下移时会真实扩出目标行，而不是钳死在 viewport 内", () => {
|
||
const options = { bufferCols: 10, bufferRows: 2, maxEntries: 20, maxBytes: 1024 };
|
||
const result = applyTerminalOutput(createEmptyState(), "\u001b[3BZ", options);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["", "", "", "Z"]);
|
||
expect(result.state.cursorRow).toBe(3);
|
||
expect(result.state.cursorCol).toBe(1);
|
||
});
|
||
|
||
it("origin mode 下的 VPA/CUP 会以滚动区顶部为基准定位", () => {
|
||
const options = { bufferCols: 10, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const result = applyTerminalOutput(
|
||
createEmptyState(),
|
||
"\u001b[2;4r\u001b[?6h\u001b[2dA\u001b[1;3HZ",
|
||
options
|
||
);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["", " Z", "A"]);
|
||
expect(result.state.cursorRow).toBe(1);
|
||
expect(result.state.cursorCol).toBe(3);
|
||
});
|
||
|
||
it("normal buffer 有历史时，开启 origin mode 会把光标归位到当前滚动区顶部", () => {
|
||
const options = { bufferCols: 10, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const base = applyTerminalOutput(createEmptyState(), "1\r\n2\r\n3\r\n4\r\n5", options);
|
||
const result = applyTerminalOutput(base.state, "\u001b[2;4r\u001b[?6hX", options);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([
|
||
"1",
|
||
"2",
|
||
"X",
|
||
"4",
|
||
"5"
|
||
]);
|
||
expect(result.state.cursorRow).toBe(2);
|
||
expect(result.state.cursorCol).toBe(1);
|
||
});
|
||
|
||
it("origin mode 下的 CUU/CUD/CNL/CPL 会被滚动区夹住，不越过固定区", () => {
|
||
const options = { bufferCols: 8, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const movedUpDown = applyTerminalOutput(
|
||
createEmptyState(),
|
||
"\u001b[?1049h1\n2\n3\n4\u001b[2;4r\u001b[?6h\u001b[1;1H\u001b[AZ\u001b[3;1H\u001b[B#",
|
||
options
|
||
);
|
||
const movedPrevNextLine = applyTerminalOutput(
|
||
createEmptyState(),
|
||
"\u001b[?1049h1\n2\n3\n4\u001b[2;4r\u001b[?6h\u001b[1;3H\u001b[FZ\u001b[3;3H\u001b[EQ",
|
||
options
|
||
);
|
||
|
||
expect(movedUpDown.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["1", "Z", "3", "#"]);
|
||
expect(movedPrevNextLine.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["1", "Z", "3", "Q"]);
|
||
});
|
||
|
||
it("normal buffer 有历史时，CUU/CPL 不会越过当前视口顶部并写回隐藏历史区", () => {
|
||
const options = { bufferCols: 10, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const base = applyTerminalOutput(createEmptyState(), "1\r\n2\r\n3\r\n4\r\n5", options);
|
||
const movedUp = applyTerminalOutput(base.state, "\u001b[1;1H\u001b[AZ", options);
|
||
const movedPrevLine = applyTerminalOutput(base.state, "\u001b[1;3H\u001b[FQ", options);
|
||
|
||
expect(movedUp.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([
|
||
"1",
|
||
"Z",
|
||
"3",
|
||
"4",
|
||
"5"
|
||
]);
|
||
expect(movedUp.state.cursorRow).toBe(1);
|
||
expect(movedUp.state.cursorCol).toBe(1);
|
||
|
||
expect(movedPrevLine.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([
|
||
"1",
|
||
"Q",
|
||
"3",
|
||
"4",
|
||
"5"
|
||
]);
|
||
expect(movedPrevLine.state.cursorRow).toBe(1);
|
||
expect(movedPrevLine.state.cursorCol).toBe(1);
|
||
});
|
||
|
||
it("normal buffer 顶部滚动区上卷时会保留历史，并维持底部固定区", () => {
|
||
const options = { bufferCols: 10, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const base = applyTerminalOutput(createEmptyState(), "1\r\n2\r\n3\r\n4", options);
|
||
const result = applyTerminalOutput(base.state, "\u001b[1;3r\u001b[3;1H\n", options);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([
|
||
"1",
|
||
"2",
|
||
"3",
|
||
"",
|
||
"4"
|
||
]);
|
||
expect(result.state.cells.slice(-4).map((row: unknown[]) => lineCellsToText(row))).toEqual([
|
||
"2",
|
||
"3",
|
||
"",
|
||
"4"
|
||
]);
|
||
});
|
||
|
||
it("normal buffer 的 ESC M 会在局部滚动区顶部插入空行", () => {
|
||
const options = { bufferCols: 10, bufferRows: 6, maxEntries: 20, maxBytes: 1024 };
|
||
const base = applyTerminalOutput(createEmptyState(), "1\r\n2\r\n3\r\n4\r\n5\r\n6", options);
|
||
const result = applyTerminalOutput(base.state, "\u001b[4;6r\u001b[4;1H\u001bM", options);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([
|
||
"1",
|
||
"2",
|
||
"3",
|
||
"",
|
||
"4",
|
||
"5"
|
||
]);
|
||
});
|
||
|
||
it("ESC D / ESC E / ESC M 在 alt buffer 固定头尾区域时，不会误滚中间滚动区", () => {
|
||
const options = { bufferCols: 8, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const indResult = applyTerminalOutput(
|
||
createEmptyState(),
|
||
"\u001b[?1049h1\n2\n3\n4\u001b[2;3r\u001b[4;1H\u001bD#",
|
||
options
|
||
);
|
||
const nelResult = applyTerminalOutput(
|
||
createEmptyState(),
|
||
"\u001b[?1049h1\n2\n3\n4\u001b[2;3r\u001b[4;1H\u001bE#",
|
||
options
|
||
);
|
||
const riResult = applyTerminalOutput(
|
||
createEmptyState(),
|
||
"\u001b[?1049h1\n2\n3\n4\u001b[2;3r\u001b[1;1H\u001bM#",
|
||
options
|
||
);
|
||
|
||
expect(indResult.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["1", "2", "3", "#"]);
|
||
expect(indResult.state.cursorRow).toBe(3);
|
||
expect(indResult.state.cursorCol).toBe(1);
|
||
expect(nelResult.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["1", "2", "3", "#"]);
|
||
expect(nelResult.state.cursorRow).toBe(3);
|
||
expect(nelResult.state.cursorCol).toBe(1);
|
||
expect(riResult.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["#", "2", "3", "4"]);
|
||
expect(riResult.state.cursorRow).toBe(0);
|
||
expect(riResult.state.cursorCol).toBe(1);
|
||
});
|
||
|
||
it("ESC D / ESC M 在 normal buffer 固定头尾区域时，不会误滚正文区或回写历史区", () => {
|
||
const options = { bufferCols: 8, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const base = applyTerminalOutput(createEmptyState(), "1\r\n2\r\n3\r\n4\r\n5\r\n6", options);
|
||
const indResult = applyTerminalOutput(base.state, "\u001b[2;3r\u001b[4;1H\u001bD#", options);
|
||
const riResult = applyTerminalOutput(base.state, "\u001b[2;3r\u001b[1;1H\u001bM#", options);
|
||
|
||
expect(indResult.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([
|
||
"1",
|
||
"2",
|
||
"3",
|
||
"4",
|
||
"5",
|
||
"#"
|
||
]);
|
||
expect(indResult.state.cursorRow).toBe(5);
|
||
expect(indResult.state.cursorCol).toBe(1);
|
||
|
||
expect(riResult.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([
|
||
"1",
|
||
"2",
|
||
"#",
|
||
"4",
|
||
"5",
|
||
"6"
|
||
]);
|
||
expect(riResult.state.cursorRow).toBe(2);
|
||
expect(riResult.state.cursorCol).toBe(1);
|
||
});
|
||
|
||
it("normal buffer 的 CPR 会返回可视窗口内的行号，而不是历史绝对行号", () => {
|
||
const options = { bufferCols: 10, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const base = applyTerminalOutput(createEmptyState(), "1\r\n2\r\n3\r\n4\r\n5", options);
|
||
const result = applyTerminalOutput(base.state, "\u001b[1;1H\u001b[6n", options);
|
||
|
||
expect(result.responses).toEqual(["\u001b[1;1R"]);
|
||
});
|
||
|
||
it("接近 codex /status 的 normal buffer 重排后，不会只停在 Permissions 这一行", () => {
|
||
const options = { bufferCols: 80, bufferRows: 24, maxEntries: 200, maxBytes: 8192 };
|
||
const historyText = Array.from({ length: 30 }, (_, index) => `pre${index + 1}`).join("\r\n");
|
||
const base = applyTerminalOutput(createEmptyState(), historyText, options);
|
||
const statusPayload =
|
||
"\u001b[18;1H\u001b[J\u001b[18;24r\u001b[18;1H\u001bM\u001bM\u001b[r\u001b[1;19r\u001b[17;1H" +
|
||
"\r\n/status\r\n\r\nStatusHeader\r\nModel\r\nDirectory\r\nPermissions\r\nAgents\r\nAccount\r\n" +
|
||
"Collaboration\r\nSession\r\nLimit5h\r\nLimitReset\r\nWeekly\r\nWeeklyReset\r\n" +
|
||
"\u001b[r\u001b[21;3H";
|
||
const result = applyTerminalOutput(base.state, statusPayload, options);
|
||
const visibleTail = result.state.cells.slice(-24).map((row: unknown[]) => lineCellsToText(row));
|
||
|
||
expect(visibleTail).toContain("Permissions");
|
||
expect(visibleTail).toContain("Weekly");
|
||
expect(visibleTail).toContain("WeeklyReset");
|
||
});
|
||
|
||
it("DECRQM 会按当前实现真实维护的模式位返回状态", () => {
|
||
const options = { bufferCols: 10, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const result = applyTerminalOutput(
|
||
createEmptyState(),
|
||
"\u001b[?1004h\u001b[4h\u001b[?1049$p\u001b[?1004$p\u001b[4$p\u001b[?2026$p",
|
||
options
|
||
);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([""]);
|
||
expect(result.responses).toEqual([
|
||
"\u001b[?1049;2$y",
|
||
"\u001b[?1004;1$y",
|
||
"\u001b[4;1$y",
|
||
"\u001b[?2026;0$y"
|
||
]);
|
||
});
|
||
|
||
it("DCS $ q 状态字符串查询会返回最小可用响应", () => {
|
||
const options = { bufferCols: 10, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const result = applyTerminalOutput(
|
||
createEmptyState(),
|
||
"\u001bP$qm\u001b\\\u001bP$qr\u001b\\\u001bP$q q\u001b\\\u001bP$qz\u001b\\",
|
||
options
|
||
);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([""]);
|
||
expect(result.responses).toEqual([
|
||
"\u001bP1$r0m\u001b\\",
|
||
"\u001bP1$r1;4r\u001b\\",
|
||
"\u001bP1$r2 q\u001b\\",
|
||
"\u001bP0$r\u001b\\"
|
||
]);
|
||
});
|
||
|
||
it("DECSTR 会软重置模式位、样式和滚动区域，但保留现有屏幕内容", () => {
|
||
const options = { bufferCols: 10, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const result = applyTerminalOutput(
|
||
createEmptyState(),
|
||
"\u001b[?1049h\u001b[2;3r\u001b[?25l\u001b[?1h\u001b[?2004h\u001b[31mX\u001b[!p",
|
||
options
|
||
);
|
||
const active = getActiveTerminalBuffer(result.state);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["X", "", "", ""]);
|
||
expect(result.state.ansiState).toEqual(ANSI_RESET_STATE);
|
||
expect(result.state.modes).toMatchObject({
|
||
applicationCursorKeys: false,
|
||
originMode: false,
|
||
wraparound: true,
|
||
cursorHidden: false,
|
||
bracketedPasteMode: false
|
||
});
|
||
expect(active.scrollTop).toBe(0);
|
||
expect(active.scrollBottom).toBe(3);
|
||
expect(active.savedCursorRow).toBe(0);
|
||
expect(active.savedCursorCol).toBe(0);
|
||
expect(active.savedAnsiState).toEqual(ANSI_RESET_STATE);
|
||
});
|
||
|
||
it("CSI 2J 清屏后保留当前光标位置，后续输出不会错位到左上角", () => {
|
||
const options = { bufferCols: 6, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const result = applyTerminalOutput(createEmptyState(), "ABCD\u001b[1;3H\u001b[2JX", options);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([" X", "", "", ""]);
|
||
expect(result.state.cursorRow).toBe(0);
|
||
expect(result.state.cursorCol).toBe(3);
|
||
});
|
||
|
||
it("带背景色的清屏会把整屏空白位也染成当前擦除背景，而不是只给文字底部上色", () => {
|
||
const options = { bufferCols: 6, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const result = applyTerminalOutput(createEmptyState(), "\u001b[100m\u001b[2JX", options);
|
||
const firstRow = result.state.cells[0];
|
||
const secondRow = result.state.cells[1];
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["X", "", "", ""]);
|
||
expect(firstRow[1]).toMatchObject({
|
||
placeholder: true,
|
||
style: { bg: "#666666" }
|
||
});
|
||
expect(secondRow[0]).toMatchObject({
|
||
placeholder: true,
|
||
style: { bg: "#666666" }
|
||
});
|
||
});
|
||
|
||
it("CSI X 会从当前光标起按列擦除字符而不左移后续内容", () => {
|
||
const options = { bufferCols: 8, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const result = applyTerminalOutput(createEmptyState(), "abcdef\u001b[1;3H\u001b[2X", options);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["ab ef"]);
|
||
expect(result.state.cursorRow).toBe(0);
|
||
expect(result.state.cursorCol).toBe(2);
|
||
});
|
||
|
||
it("CSI @ / P 会按当前光标插删行内字符，而不是重写整行", () => {
|
||
const options = { bufferCols: 8, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const inserted = applyTerminalOutput(createEmptyState(), "abcd\u001b[1;3H\u001b[@Z", options);
|
||
const deleted = applyTerminalOutput(createEmptyState(), "abcdef\u001b[1;3H\u001b[2P", options);
|
||
|
||
expect(inserted.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["abZcd"]);
|
||
expect(inserted.state.cursorRow).toBe(0);
|
||
expect(inserted.state.cursorCol).toBe(3);
|
||
expect(deleted.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["abef"]);
|
||
expect(deleted.state.cursorRow).toBe(0);
|
||
expect(deleted.state.cursorCol).toBe(2);
|
||
});
|
||
|
||
it("CSI @ / P 切进宽字符中间时，不会留下悬空 continuation 或半个宽字符", () => {
|
||
const options = { bufferCols: 5, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const inserted = applyTerminalOutput(createEmptyState(), "A中BC\u001b[1;3H\u001b[@", options);
|
||
const deleted = applyTerminalOutput(createEmptyState(), "A中BC\u001b[1;2H\u001b[P", options);
|
||
|
||
expect(inserted.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["A B"]);
|
||
expect(deleted.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["A BC"]);
|
||
expect(
|
||
inserted.state.cells[0].some((cell: { continuation?: boolean }) => !!cell && !!cell.continuation)
|
||
).toBe(false);
|
||
expect(
|
||
deleted.state.cells[0].some((cell: { continuation?: boolean }) => !!cell && !!cell.continuation)
|
||
).toBe(false);
|
||
});
|
||
|
||
it("normal buffer 有历史和固定头尾时，CSI L / M / S / T 只作用于当前滚动区", () => {
|
||
const options = { bufferCols: 8, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const base = applyTerminalOutput(createEmptyState(), "1\r\n2\r\n3\r\n4\r\n5\r\n6", options);
|
||
const inserted = applyTerminalOutput(base.state, "\u001b[2;3r\u001b[2;1H\u001b[L", options);
|
||
const deleted = applyTerminalOutput(base.state, "\u001b[2;3r\u001b[2;1H\u001b[M", options);
|
||
const scrolledUp = applyTerminalOutput(base.state, "\u001b[2;3r\u001b[S", options);
|
||
const scrolledDown = applyTerminalOutput(base.state, "\u001b[2;3r\u001b[T", options);
|
||
|
||
expect(inserted.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([
|
||
"1",
|
||
"2",
|
||
"3",
|
||
"",
|
||
"4",
|
||
"6"
|
||
]);
|
||
expect(deleted.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([
|
||
"1",
|
||
"2",
|
||
"3",
|
||
"5",
|
||
"",
|
||
"6"
|
||
]);
|
||
expect(scrolledUp.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([
|
||
"1",
|
||
"2",
|
||
"3",
|
||
"5",
|
||
"",
|
||
"6"
|
||
]);
|
||
expect(scrolledDown.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual([
|
||
"1",
|
||
"2",
|
||
"3",
|
||
"",
|
||
"4",
|
||
"6"
|
||
]);
|
||
});
|
||
|
||
it("CSI L / M 会在 alt buffer 当前行插删整行", () => {
|
||
const options = { bufferCols: 8, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const inserted = applyTerminalOutput(
|
||
createEmptyState(),
|
||
"\u001b[?1049h1\n2\n3\n4\u001b[2;1H\u001b[L",
|
||
options
|
||
);
|
||
const deleted = applyTerminalOutput(
|
||
createEmptyState(),
|
||
"\u001b[?1049h1\n2\n3\n4\u001b[2;1H\u001b[M",
|
||
options
|
||
);
|
||
|
||
expect(inserted.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["1", "", "2", "3"]);
|
||
expect(inserted.state.cursorRow).toBe(1);
|
||
expect(inserted.state.cursorCol).toBe(0);
|
||
expect(deleted.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["1", "3", "4", ""]);
|
||
expect(deleted.state.cursorRow).toBe(1);
|
||
expect(deleted.state.cursorCol).toBe(0);
|
||
});
|
||
|
||
it("CSI S / T 会在当前滚动区内上卷和下卷，而不改动其它语义", () => {
|
||
const options = { bufferCols: 8, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const scrolledUp = applyTerminalOutput(createEmptyState(), "\u001b[?1049h1\n2\n3\n4\u001b[S", options);
|
||
const scrolledDown = applyTerminalOutput(createEmptyState(), "\u001b[?1049h1\n2\n3\n4\u001b[T", options);
|
||
|
||
expect(scrolledUp.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["2", "3", "4", ""]);
|
||
expect(scrolledUp.state.cursorRow).toBe(3);
|
||
expect(scrolledUp.state.cursorCol).toBe(1);
|
||
expect(scrolledDown.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["", "1", "2", "3"]);
|
||
expect(scrolledDown.state.cursorRow).toBe(3);
|
||
expect(scrolledDown.state.cursorCol).toBe(1);
|
||
});
|
||
|
||
it("CSI r 只给顶部参数时会把底边默认到最后一行", () => {
|
||
const options = { bufferCols: 8, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const base = applyTerminalOutput(createEmptyState(), "1\r\n2\r\n3\r\n4", options);
|
||
const result = applyTerminalOutput(base.state, "\u001b[2r\u001b[4;1H\n", options);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["1", "3", "4", ""]);
|
||
expect(result.state.cursorRow).toBe(3);
|
||
expect(result.state.cursorCol).toBe(0);
|
||
});
|
||
|
||
it("insert mode 打开后，普通打印会按当前光标位置插入而不是覆盖", () => {
|
||
const options = { bufferCols: 8, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const result = applyTerminalOutput(createEmptyState(), "abcd\u001b[1;3H\u001b[4hZ", options);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["abZcd"]);
|
||
expect(result.state.cursorRow).toBe(0);
|
||
expect(result.state.cursorCol).toBe(3);
|
||
expect(result.state.modes.insertMode).toBe(true);
|
||
});
|
||
|
||
it("ESC D / ESC E / ESC M 会按滚动区域语义推进全屏缓冲", () => {
|
||
const options = { bufferCols: 8, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const indResult = applyTerminalOutput(
|
||
createEmptyState(),
|
||
"\u001b[?1049h1\n2\n3\n4\u001b[2;4r\u001b[4;1H\u001bD",
|
||
options
|
||
);
|
||
const nelResult = applyTerminalOutput(indResult.state, "\u001bE#", options);
|
||
const riResult = applyTerminalOutput(nelResult.state, "\u001b[2;1H\u001bM", options);
|
||
|
||
expect(indResult.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["1", "3", "4", ""]);
|
||
expect(nelResult.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["1", "4", "", "#"]);
|
||
expect(nelResult.state.cursorRow).toBe(3);
|
||
expect(nelResult.state.cursorCol).toBe(1);
|
||
expect(riResult.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["1", "", "4", ""]);
|
||
expect(riResult.state.cursorRow).toBe(1);
|
||
expect(riResult.state.cursorCol).toBe(0);
|
||
});
|
||
|
||
it("CSI s/u 与 ESC 7/8 会恢复之前保存的光标位置", () => {
|
||
const options = { bufferCols: 8, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const csiResult = applyTerminalOutput(createEmptyState(), "ab\u001b[scd\u001b[uZ", options);
|
||
const escResult = applyTerminalOutput(createEmptyState(), "ab\u001b7cd\u001b8Z", options);
|
||
|
||
expect(csiResult.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["abZd"]);
|
||
expect(csiResult.state.cursorRow).toBe(0);
|
||
expect(csiResult.state.cursorCol).toBe(3);
|
||
expect(escResult.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["abZd"]);
|
||
expect(escResult.state.cursorRow).toBe(0);
|
||
expect(escResult.state.cursorCol).toBe(3);
|
||
});
|
||
|
||
it("带 > 私有标记的 CSI u 不应误当成光标恢复", () => {
|
||
const options = { bufferCols: 8, bufferRows: 4, maxEntries: 20, maxBytes: 1024 };
|
||
const result = applyTerminalOutput(createEmptyState(), "abc\u001b[>7uZ", options);
|
||
|
||
expect(result.state.cells.map((row: unknown[]) => lineCellsToText(row))).toEqual(["abcZ"]);
|
||
expect(result.state.cursorRow).toBe(0);
|
||
expect(result.state.cursorCol).toBe(4);
|
||
});
|
||
});
|
||
|
||
function createEmptyState() {
|
||
return {
|
||
cells: [[]],
|
||
ansiState: { ...ANSI_RESET_STATE },
|
||
cursorRow: 0,
|
||
cursorCol: 0
|
||
};
|
||
}
|