@tuidom/core 0.2.1 → 0.3.0

package/dist/backend/iTerminalBackend.d.ts

@@ -27,6 +27,16 @@ export interface ITerminalBackend {
      * reply within the probe window). Fire-and-forget — callers must not block on it.
      */
     probeKeyboardProtocol(onResult: (supported: boolean) => void): void;
+    /**
+     * Asynchronously ask the terminal for its name and version (XTVERSION: `CSI > 0 q`
+     * → `DCS > | <name(version)> ST`). `onResult` fires exactly once with the reported
+     * string as-is (e.g. `"iTerm2 3.5.0"`, `"kitty(0.35.2)"`, `"WezTerm 20240203…"`), or
+     * `undefined` if the terminal doesn't answer within the probe window. The reply is
+     * consumed by the backend and never reaches `onInput`. Inside tmux the query goes
+     * to tmux itself (like the other probes), so the answer is tmux's own (`"tmux 3.4"`).
+     * Fire-and-forget — callers must not block on it.
+     */
+    probeTerminalVersion(onResult: (nameAndVersion: string | undefined) => void): void;
     /**
      * Render a frame: receive the current grid and cursor position.
      * The backend decides how to output it (ANSI diffing, simple copy, etc.).

package/dist/dom/tuiApplication.js

@@ -158,8 +158,14 @@ export class TuiApplication {
                     target.dispatchEvent(contextMenuEvent);
                 }
             }
-            // Tab focus cycling (default behavior if not prevented, only on keydown)
-            if (notPrevented && event.key === "Tab" && event.type === "keydown" && this.focusManager) {
+            // Tab focus cycling (default behavior if not prevented, only on keydown).
+            // Обход фокуса — только у голого Tab и Shift+Tab: Ctrl+Tab, Alt+Tab и Meta+Tab
+            // это отдельные аккорды, и приложение вправе повесить на них своё. Если бы
+            // мы крутили кольцо и на них, то нерезолвнувшийся аккорд приложения (его
+            // `when` не прошёл — значит preventDefault никто не позвал) уводил бы фокус
+            // на случайный элемент. Shift здесь не модификатор аккорда, а направление.
+            const plainTab = !event.ctrlKey && !event.altKey && !event.metaKey;
+            if (notPrevented && event.key === "Tab" && event.type === "keydown" && plainTab && this.focusManager) {
                 const direction = event.shiftKey ? "backward" : "forward";
                 this.focusManager.cycleFocus(direction);
             }

package/dist/dom/tuiElement.js

@@ -379,7 +379,9 @@ export class TUIElement {
     /** Гасит фокус, если activeElement — этот элемент или его потомок. */
     releaseFocusIfInside() {
         const fm = this.getRoot()?.focusManager ?? null;
-        let node = fm?.activeElement ?? null;
+        if (fm === null)
+            return;
+        let node = fm.activeElement ?? null;
         while (node !== null && node !== this) {
             node = node.getParent();
         }
@@ -731,6 +733,7 @@ export class TUIElement {
      * состояние нужно ДО стилевого прохода, прямо в performLayout.
      */
     hasStyleStateWithin(state) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
         let node = this;
         while (node !== null) {
             if (node.styleStatesSet?.has(state) === true)
@@ -769,6 +772,7 @@ export class TUIElement {
         // цепочка предков (иначе любой markDirty = полноэкранный damage).
         this.isPaintDirty = true;
         this.isLayoutDirty = true;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
         let top = this;
         for (let current = this._parent; current !== null; current = current._parent) {
             current.isLayoutDirty = true;
@@ -802,7 +806,11 @@ export class TUIElement {
         }
         const rect = new Rect(new Point(parentOrigin.x + this.localPosition.dx, parentOrigin.y + this.localPosition.dy), this.allocatedSize);
         const old = this.lastPaintedRect;
-        const moved = old === null ||
+        // Ещё не рисовался — тоже moved. Optional chain здесь не подходит: после
+        // первого `old?.x` тип уже сужен, и остальные `old?.` стали бы лишними.
+        const moved = 
+        // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+        old === null ||
             old.x !== rect.x ||
             old.y !== rect.y ||
             old.width !== rect.width ||
@@ -835,6 +843,9 @@ export class TUIElement {
      * собственный хром по состоянию ребёнка вне его rect'а (ScrollBarDecorator:
      * бегунок в колонке за пределами ребёнка).
      */
+    // Именно геттер, не readonly-поле: подклассы переопределяют его геттером
+    // (ListViewElement, ScrollContainerElement), а поле базы затенило бы их прототипный аксессор.
+    // eslint-disable-next-line @typescript-eslint/class-literal-property-style
     get paintsSubtreeAtomically() {
         return false;
     }

package/dist/input/keyInputParser.js

@@ -1,6 +1,6 @@
 import { convertTokenToKeyPressEvent } from "./convertToken.js";
 import { createKeyPressEvent } from "./keyEvent.js";
-import { parseCSI, parseOSC, tokenize } from "./tokenize.js";
+import { parseCSI, parseOSC, parseXtversionReply, tokenize, XTVERSION_REPLY_PREFIX } from "./tokenize.js";
 /**
  * Index where an *incomplete* trailing escape sequence begins, or -1 if `data`
  * ends on a clean token boundary.
@@ -16,6 +16,12 @@ import { parseCSI, parseOSC, tokenize } from "./tokenize.js";
  * incomplete — anything before it is already followed by more bytes.
  */
 function incompleteTailStart(data) {
+    // Ответ XTVERSION (`ESC P > | … ESC \\`) — единственная строка, внутри которой
+    // может стоять «последний» ESC (от ST, разрезанного между чтениями), поэтому тело
+    // без терминатора проверяем раньше, чем ищем последний ESC.
+    const dcs = data.lastIndexOf(XTVERSION_REPLY_PREFIX);
+    if (dcs !== -1 && parseXtversionReply(data, dcs) === null)
+        return dcs;
     const esc = data.lastIndexOf("\x1b");
     if (esc === -1)
         return -1;
@@ -30,6 +36,10 @@ function incompleteTailStart(data) {
         return parseOSC(data, esc) === null ? esc : -1; // ESC ]
     if (next === 0x4f)
         return esc + 2 >= data.length ? esc : -1; // ESC O (SS3) needs its final letter
+    // ESC P: незавершённое начало ответа XTVERSION (`ESC P >`) ждём. Хвост, уже
+    // разошедшийся с префиксом, — обычный Alt+Shift+P (ESC + символ), он завершён.
+    if (next === 0x50)
+        return XTVERSION_REPLY_PREFIX.startsWith(data.slice(esc)) ? esc : -1;
     // ESC + printable / control / special is complete once the second byte is present (it is).
     return -1;
 }

package/dist/input/rawTerminalToken.d.ts

@@ -111,18 +111,24 @@ export interface OscToken {
     readonly raw: string;
 }
 /**
- * A private-mode CSI response to one of our capability probes — NOT a key event.
+ * A response to one of our capability probes — NOT a key event.
  *  - "kitty-flags": reply to the Kitty keyboard-protocol query `CSI ? u` → `CSI ? <flags> u`.
  *  - "da1":         reply to Primary Device Attributes `CSI c` → `CSI ? <attrs> c`.
- * These begin with the private marker `?`, which never appears in a real key event.
+ *  - "xtversion":   reply to XTVERSION `CSI > 0 q` → `DCS > | <name(version)> ST`.
+ * The CSI replies begin with the private marker `?`, which never appears in a real key
+ * event; the XTVERSION reply is a DCS string (`ESC P > |`), not a key either.
  */
 export interface DeviceReportToken {
     readonly kind: "device-report";
-    readonly report: "kitty-flags" | "da1";
-    /** Raw parameter bytes including the leading `?` (e.g. "?15" or "?62;1;6"). */
+    readonly report: DeviceReportKind;
+    /**
+     * For CSI replies — raw parameter bytes including the leading `?` (e.g. "?15" or
+     * "?62;1;6"). For "xtversion" — the payload between `DCS > |` and ST (e.g. "iTerm2 3.5.0").
+     */
     readonly params: string;
     readonly raw: string;
 }
+export type DeviceReportKind = "kitty-flags" | "da1" | "xtversion";
 export type MouseButton = "left" | "middle" | "right" | "none";
 export type MouseAction = "press" | "release" | "move" | "scroll-up" | "scroll-down" | "scroll-left" | "scroll-right";
 export interface MouseToken {

package/dist/input/serializeKey.d.ts

@@ -8,7 +8,10 @@
  *   serializeKey('Ctrl+ArrowUp')   → '\x1b[1;5A'
  *   serializeKey('F5')             → '\x1b[15~'
  *   serializeKey('Alt+a')          → '\x1ba'
+ *   serializeKey('Meta+s')         → '\x1b[115;9u'
+ *   serializeKey('Ctrl+Shift+a')   → '\x1b[97;6u'
  *
  * Supports modifier prefixes: Ctrl+, Shift+, Alt+, Meta+ (combinable).
+ * Meta — это super-бит kitty (8): так приходит Cmd на маке.
  */
 export declare function serializeKey(name: string): string;

package/dist/input/serializeKey.js

@@ -8,9 +8,13 @@
  *   serializeKey('Ctrl+ArrowUp')   → '\x1b[1;5A'
  *   serializeKey('F5')             → '\x1b[15~'
  *   serializeKey('Alt+a')          → '\x1ba'
+ *   serializeKey('Meta+s')         → '\x1b[115;9u'
+ *   serializeKey('Ctrl+Shift+a')   → '\x1b[97;6u'
  *
  * Supports modifier prefixes: Ctrl+, Shift+, Alt+, Meta+ (combinable).
+ * Meta — это super-бит kitty (8): так приходит Cmd на маке.
  */
+import { kittyCodepointMap } from "./tokenize.js";
 /** Simple special keys (no modifiers, no CSI) */
 const simpleSpecialKeys = {
     Enter: "\x0d",
@@ -73,6 +77,24 @@ function encodeModifier(ctrl, shift, alt, meta) {
         mod += 8;
     return mod;
 }
+/**
+ * Codepoint для общей CSI u-формы, если `ch` — один печатный символ, который
+ * parseInput вернёт как есть: не управляющий и не занятый kitty под
+ * функциональную клавишу (PUA). Буква сворачивается в нижний регистр — так
+ * kitty шлёт базовую клавишу; регистр в событии даёт Shift-бит.
+ */
+function printableCodepoint(ch) {
+    const lower = ch.toLowerCase();
+    const codepoint = lower.codePointAt(0);
+    // Пусто («Meta+»), имя клавиши («Foo») или буква, чей lowercase — не один символ («İ»).
+    if (codepoint === undefined || String.fromCodePoint(codepoint) !== lower)
+        return undefined;
+    if (codepoint < 0x20 || (codepoint >= 0x7f && codepoint <= 0x9f))
+        return undefined;
+    if (kittyCodepointMap[codepoint] !== undefined)
+        return undefined;
+    return codepoint;
+}
 export function serializeKey(name) {
     // Parse modifier prefixes: "Ctrl+Shift+ArrowUp" → modifiers + "ArrowUp"
     let ctrl = false;
@@ -175,5 +197,15 @@ export function serializeKey(name) {
     if (!hasModifiers && remaining.length === 1) {
         return remaining;
     }
+    // Печатный символ с любым другим набором модификаторов — общая форма kitty
+    // CSI <codepoint>;<mod>u. Сюда доходят только комбинации, у которых нет
+    // legacy-кодировки (ветки выше их уже вернули): Meta+s, Ctrl+Shift+a, Shift+1…
+    // Как и kitty, шлём codepoint базовой клавиши: буква — в нижнем регистре, а
+    // регистр задаёт только Shift-префикс (Meta+S ≡ Meta+s, как Ctrl+A ≡ Ctrl+a).
+    const codepoint = printableCodepoint(remaining === "Space" ? " " : remaining);
+    if (codepoint !== undefined) {
+        const mod = encodeModifier(ctrl, shift, alt, meta);
+        return `\x1b[${codepoint.toString()};${mod.toString()}u`;
+    }
     throw new Error(`serializeKey: unknown key name "${name}". Add it to the mapping.`);
 }

package/dist/input/tokenize.d.ts

@@ -56,4 +56,17 @@ interface OSCTokenResult {
  * Returns null if the sequence is not complete.
  */
 export declare function parseOSC(data: string, start: number): OSCTokenResult | null;
+/**
+ * Начало ответа на XTVERSION (`CSI > 0 q`): `DCS > |`. Разбираем только его: голое
+ * `ESC P` — это ещё и Alt+Shift+P legacy-терминала, так что произвольный DCS не ловим.
+ */
+export declare const XTVERSION_REPLY_PREFIX = "\u001BP>|";
+/**
+ * Parse an XTVERSION reply `ESC P > | <text> ESC \` starting at data[start] = ESC.
+ * Returns null if the string terminator (ST) hasn't arrived yet.
+ */
+export declare function parseXtversionReply(data: string, start: number): {
+    token: DeviceReportToken;
+    nextIndex: number;
+} | null;
 export {};

package/dist/input/tokenize.js

@@ -57,6 +57,18 @@ export function tokenize(data) {
                 tokens.push({ kind: "standalone-esc", raw: data[i] });
                 i++;
             }
+            else if (next === 0x50 && data.startsWith(XTVERSION_REPLY_PREFIX, i)) {
+                // DCS-ответ на XTVERSION: \x1bP>|<name(version)>\x1b\\. Без ST (обрезан, и
+                // KeyInputParser его уже не ждёт) — падаем в ESC+символ, как было до разбора DCS.
+                const dcsResult = parseXtversionReply(data, i);
+                if (dcsResult) {
+                    tokens.push(dcsResult.token);
+                    i = dcsResult.nextIndex;
+                    continue;
+                }
+                tokens.push({ kind: "esc-char", char: data[i + 1], charCode: next, raw: data.slice(i, i + 2) });
+                i += 2;
+            }
             else if (next === 0x4f) {
                 // SS3 sequence: \x1bO<letter>
                 if (i + 2 < data.length) {
@@ -679,3 +691,29 @@ function buildOscResult(body, raw, nextIndex) {
         nextIndex,
     };
 }
+// ─── DCS: XTVERSION reply ───
+/**
+ * Начало ответа на XTVERSION (`CSI > 0 q`): `DCS > |`. Разбираем только его: голое
+ * `ESC P` — это ещё и Alt+Shift+P legacy-терминала, так что произвольный DCS не ловим.
+ */
+export const XTVERSION_REPLY_PREFIX = "\x1bP>|";
+/**
+ * Parse an XTVERSION reply `ESC P > | <text> ESC \` starting at data[start] = ESC.
+ * Returns null if the string terminator (ST) hasn't arrived yet.
+ */
+export function parseXtversionReply(data, start) {
+    const bodyStart = start + XTVERSION_REPLY_PREFIX.length;
+    const end = data.indexOf("\x1b\\", bodyStart);
+    if (end === -1)
+        return null;
+    const nextIndex = end + 2;
+    return {
+        token: {
+            kind: "device-report",
+            report: "xtversion",
+            params: data.slice(bodyStart, end),
+            raw: data.slice(start, nextIndex),
+        },
+        nextIndex,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tuidom/core",
-    "version": "0.2.1",
+    "version": "0.3.0",
     "type": "module",
     "description": "Experimental terminal UI DOM — core: element tree, flex layout, grid rendering, input parsing. API is unstable.",
     "license": "MIT",