Files
Netcatty/components/terminal/runtime/cursorPreference.test.ts
T
OOKAMISAMAandbincxz 6ece7e8222 feat(terminal): Add configurable terminal bar cursor width (#3495)
* feat(terminal): Add configurable terminal bar cursor width

Adds a configurable bar-cursor width for the terminal so thin vertical cursors are easier to find, particularly when vi/vim switches to insert mode.

* Add terminal bar cursor width setting

This adds the terminal bar cursor width control to the settings UI with an aria-label for accessibility and a matching test. It also adds localized labels/descriptions and search catalog entries so the setting is discoverable in both English and Chinese.

* Fix terminal cursor width override bug

Prevent width-only cursor updates from clearing DEC/vi cursor overrides by tracking the last applied shape/blink snapshot. The runtime now resets the snapshot on teardown, skips full cursor reapplication for width-only changes, and preserves remote bar/underline cursor styles. Added regression tests covering boot-time and later width updates.

* Fix terminal cursor preference lifecycle

Preserve DEC/vi cursor overrides during the first width-only terminal update after runtime creation. The runtime now records the user cursor preference snapshot when a term is published and applies width-only updates without clearing active cursor style or blink overrides. This prevents regressions when terminal settings change before the panel has fully booted.

---------

Co-authored-by: bincxz <16399091+binaricat@users.noreply.github.com>
2026-09-29 00:24:27 +08:00

283 lines
8.0 KiB
TypeScript

import test from "node:test";
import assert from "node:assert/strict";
import {
applyUserCursorBlinkPreference,
applyUserCursorPreference,
applyUserCursorWidthPreference,
installUserCursorPreferenceGuard,
resolveUserCursorPreference,
shouldApplyUserCursorPreference,
snapshotUserCursorPreference,
} from "./cursorPreference";
test("resolveUserCursorPreference defaults to a blinking block cursor", () => {
assert.deepEqual(resolveUserCursorPreference(undefined), {
cursorShape: "block",
cursorBlink: true,
cursorBarWidth: 2,
});
});
test("shouldApplyUserCursorPreference applies full preferences only for shape or blink changes", () => {
const previous = snapshotUserCursorPreference({
cursorShape: "block",
cursorBlink: true,
});
assert.equal(
shouldApplyUserCursorPreference(previous, snapshotUserCursorPreference({
cursorShape: "block",
cursorBlink: true,
cursorBarWidth: 4,
})),
false,
);
assert.equal(
shouldApplyUserCursorPreference(previous, snapshotUserCursorPreference({
cursorShape: "bar",
cursorBlink: true,
})),
true,
);
assert.equal(
shouldApplyUserCursorPreference(previous, snapshotUserCursorPreference({
cursorShape: "block",
cursorBlink: false,
})),
true,
);
});
test("applyUserCursorPreference clears terminal-side cursor overrides before applying user settings", () => {
const term = {
options: {
cursorStyle: "block" as const,
cursorBlink: false,
},
_core: {
coreService: {
decPrivateModes: {
cursorStyle: "bar" as const,
cursorBlink: false,
},
},
},
};
applyUserCursorPreference(term, {
cursorShape: "underline",
cursorBlink: true,
});
assert.equal(term.options.cursorStyle, "underline");
assert.equal(term.options.cursorBlink, true);
assert.equal((term.options as { cursorWidth?: number }).cursorWidth, 2);
assert.equal(term._core.coreService.decPrivateModes.cursorStyle, undefined);
assert.equal(term._core.coreService.decPrivateModes.cursorBlink, undefined);
});
test("resolveUserCursorPreference clamps bar cursor width to the supported range", () => {
assert.equal(resolveUserCursorPreference({ cursorBarWidth: 9 }).cursorBarWidth, 4);
assert.equal(resolveUserCursorPreference({ cursorBarWidth: 0 }).cursorBarWidth, 1);
});
test("first width update after runtime creation preserves a remote DEC bar cursor", () => {
const initialSnapshot = snapshotUserCursorPreference({
cursorShape: "block",
cursorBlink: true,
cursorBarWidth: 2,
});
const nextSettings = {
cursorShape: "block" as const,
cursorBlink: true,
cursorBarWidth: 3,
};
const term = {
options: {
cursorStyle: "block" as const,
cursorBlink: true,
},
_core: {
coreService: {
decPrivateModes: {
cursorStyle: "bar" as const,
cursorBlink: true,
},
},
},
};
const nextSnapshot = snapshotUserCursorPreference(nextSettings);
assert.equal(shouldApplyUserCursorPreference(initialSnapshot, nextSnapshot), false);
applyUserCursorWidthPreference(term, nextSettings);
assert.equal((term.options as { cursorWidth?: number }).cursorWidth, 3);
assert.equal(term._core.coreService.decPrivateModes.cursorStyle, "bar");
});
test("applyUserCursorWidthPreference preserves a remote DEC cursor-style override", () => {
const term = {
options: {
cursorStyle: "block" as const,
cursorBlink: true,
},
_core: {
coreService: {
decPrivateModes: {
cursorStyle: "bar" as const,
cursorBlink: false,
},
},
},
};
applyUserCursorWidthPreference(term, { cursorBarWidth: 3 });
assert.equal((term.options as { cursorWidth?: number }).cursorWidth, 3);
assert.equal(term.options.cursorStyle, "block");
assert.equal(term._core.coreService.decPrivateModes.cursorStyle, "bar");
assert.equal(term._core.coreService.decPrivateModes.cursorBlink, false);
});
test("width updates preserve a remote DEC underline cursor override", () => {
const term = {
options: {
cursorStyle: "block" as const,
cursorBlink: true,
},
_core: {
coreService: {
decPrivateModes: {
cursorStyle: "underline" as const,
cursorBlink: false,
},
},
},
};
applyUserCursorWidthPreference(term, { cursorBarWidth: 4 });
assert.equal((term.options as { cursorWidth?: number }).cursorWidth, 4);
assert.equal(term._core.coreService.decPrivateModes.cursorStyle, "underline");
assert.equal(term._core.coreService.decPrivateModes.cursorBlink, false);
});
test("applyUserCursorBlinkPreference keeps remote cursor shape overrides intact", () => {
const term = {
options: {
cursorStyle: "block" as const,
cursorBlink: false,
},
_core: {
coreService: {
decPrivateModes: {
cursorStyle: "bar" as const,
cursorBlink: false,
},
},
},
};
applyUserCursorBlinkPreference(term, {
cursorShape: "underline",
cursorBlink: true,
});
assert.equal(term.options.cursorStyle, "block");
assert.equal(term.options.cursorBlink, true);
assert.equal(term._core.coreService.decPrivateModes.cursorStyle, "bar");
assert.equal(term._core.coreService.decPrivateModes.cursorBlink, undefined);
});
test("installUserCursorPreferenceGuard restores blink without consuming cursor-style overrides", async () => {
const handlers = new Map<string, (params: readonly (number | number[])[]) => boolean>();
const parser = {
registerCsiHandler(this: typeof parser, id: { prefix?: string; intermediates?: string; final: string }, callback: (params: readonly (number | number[])[]) => boolean) {
assert.equal(this, parser);
handlers.set(`${id.prefix ?? ""}|${id.intermediates ?? ""}|${id.final}`, callback);
return { dispose: () => undefined };
},
};
const term = {
options: {
cursorStyle: "block" as const,
cursorBlink: false,
},
parser,
_core: {
coreService: {
decPrivateModes: {
cursorStyle: "block" as const,
cursorBlink: false,
},
},
},
};
const settingsRef = {
current: {
cursorShape: "bar",
cursorBlink: true,
},
};
installUserCursorPreferenceGuard(term, settingsRef);
const handled = handlers.get("| |q")?.([2]);
assert.equal(handled, false);
await new Promise((resolve) => {
setTimeout(resolve, 0);
});
assert.equal(term.options.cursorStyle, "block");
assert.equal(term.options.cursorBlink, true);
assert.equal(term._core.coreService.decPrivateModes.cursorStyle, "block");
assert.equal(term._core.coreService.decPrivateModes.cursorBlink, undefined);
});
test("installUserCursorPreferenceGuard restores cursor blink after private mode changes", async () => {
const handlers = new Map<string, (params: readonly (number | number[])[]) => boolean>();
const term = {
options: {
cursorStyle: "block" as const,
cursorBlink: false,
},
parser: {
registerCsiHandler: (id: { prefix?: string; intermediates?: string; final: string }, callback: (params: readonly (number | number[])[]) => boolean) => {
handlers.set(`${id.prefix ?? ""}|${id.intermediates ?? ""}|${id.final}`, callback);
return { dispose: () => undefined };
},
},
_core: {
coreService: {
decPrivateModes: {
cursorStyle: "block" as const,
cursorBlink: false,
},
},
},
};
const settingsRef = {
current: {
cursorShape: "underline",
cursorBlink: true,
},
};
installUserCursorPreferenceGuard(term, settingsRef);
const handled = handlers.get("?||l")?.([12]);
assert.equal(handled, false);
await new Promise((resolve) => {
setTimeout(resolve, 0);
});
assert.equal(term.options.cursorStyle, "block");
assert.equal(term.options.cursorBlink, true);
assert.equal(term._core.coreService.decPrivateModes.cursorStyle, "block");
assert.equal(term._core.coreService.decPrivateModes.cursorBlink, undefined);
});