@tuidom/elements 0.1.0

package/dist/terminal/encodeKeyForPty.js

@@ -0,0 +1,56 @@
+// Кодирование нажатия клавиши в байты, которые ждёт обычный PTY (xterm-совместимый).
+//
+// Пробрасывать `event.raw` напрямую нельзя: хост (NodeTerminalBackend) включает Kitty
+// keyboard protocol, и raw приходит в виде CSI-u последовательностей, а шелл ждёт
+// «легаси»-кодировку. Поэтому кодируем сами из логического `key` + модификаторов.
+//
+// Покрытие достаточно для спайка: печатные символы, ключевые управляющие клавиши,
+// стрелки/навигация и Ctrl+буква (Ctrl+C/D/Z/L …). Application-cursor-keys режим не
+// различаем — шлём стандартные CSI-последовательности.
+const SPECIAL = {
+    Enter: "\r",
+    Backspace: "\x7f",
+    Tab: "\t",
+    Escape: "\x1b",
+    Delete: "\x1b[3~",
+    Insert: "\x1b[2~",
+    ArrowUp: "\x1b[A",
+    ArrowDown: "\x1b[B",
+    ArrowRight: "\x1b[C",
+    ArrowLeft: "\x1b[D",
+    Home: "\x1b[H",
+    End: "\x1b[F",
+    PageUp: "\x1b[5~",
+    PageDown: "\x1b[6~",
+};
+/** Вернуть байты для PTY, либо "" если клавишу не транслируем. */
+export function encodeKeyForPty(event) {
+    const { key } = event;
+    // Ctrl+буква → управляющий байт 0x01..0x1a (Ctrl+A=1 … Ctrl+Z=26).
+    if (event.ctrlKey && key.length === 1) {
+        const lower = key.toLowerCase();
+        if (lower >= "a" && lower <= "z") {
+            return String.fromCharCode(lower.charCodeAt(0) - 96);
+        }
+        // Немного распространённых Ctrl-символов.
+        switch (key) {
+            case " ":
+                return "\x00"; // Ctrl+Space → NUL
+            case "[":
+                return "\x1b";
+            case "\\":
+                return "\x1c";
+            case "]":
+                return "\x1d";
+        }
+    }
+    const special = SPECIAL[key];
+    if (special !== undefined) {
+        return special;
+    }
+    // Печатный символ. Alt/Meta → ESC-префикс (meta-байт).
+    if (key.length === 1 && !event.ctrlKey) {
+        return event.altKey || event.metaKey ? "\x1b" + key : key;
+    }
+    return "";
+}

package/dist/terminal/terminalViewElement.d.ts

@@ -0,0 +1,17 @@
+import { BoxConstraints, Size } from "@tuidom/core/common/geometryPromitives";
+import type { ITerminalSurface } from "@tuidom/core/common/iTerminalSurface";
+import type { TUIEventBase } from "@tuidom/core/dom/events/tuiEventBase";
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+export declare class TerminalViewElement extends TUIElement {
+    private readonly surface;
+    private readonly cell;
+    private readonly subscriptions;
+    constructor(surface: ITerminalSurface);
+    /** Рвёт подписки на поверхность. Вызывается владельцем виджета (контроллером). */
+    dispose(): void;
+    private forwardMouse;
+    private sendMouse;
+    protected performLayout(constraints: BoxConstraints): Size;
+    render(context: RenderContext): void;
+    protected performDefaultAction(event: TUIEventBase): void;
+}

package/dist/terminal/terminalViewElement.js

@@ -0,0 +1,172 @@
+// Контрол отрисовки терминала — «клиент» встроенного терминала.
+//
+// TUIElement-лист: каждый кадр читает абстрактную сетку ячеек через `ITerminalSurface`
+// и блитит её в наш grid через `RenderContext.setCell`. Виджет НЕ знает про PTY/эмулятор:
+// вся связка (node-pty + @xterm/headless) живёт за `ITerminalSurface` на слое Workbench,
+// поэтому TUIDom остаётся чистым (без импортов @xterm/headless и node-pty).
+// Размером PTY управляет по реально выделенному месту (`performLayout` → `surface.resize`),
+// поэтому ресайз окна автоматически рефлоует шелл. Ввод пробрасывает в surface через
+// `encodeKeyForPty`. Колесо и Shift+PageUp/PageDown крутят вьюпорт по скролбэку
+// (`surface.scrollLines`), пока программа в шелле не включила свой mouse-tracking —
+// тогда колесо целиком её. См. docs/TODO/IntegratedTerminal.md.
+import { DEFAULT_COLOR } from "@tuidom/core/common/colorUtils";
+import { BoxConstraints, Size } from "@tuidom/core/common/geometryPromitives";
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+import { encodeKeyForPty } from "./encodeKeyForPty.js";
+// wheelDirection ("up"|"down"|"left"|"right") → семантический action поверхности.
+// Ключи типизированы точно (WheelDirection, а не string) — индексация тотальна,
+// недостижимый фоллбэк на «неизвестное» направление не нужен.
+const WHEEL_ACTION = {
+    up: "wheelUp",
+    down: "wheelDown",
+    left: "wheelLeft",
+    right: "wheelRight",
+};
+// Локальная прокрутка вьюпорта колесом: строк на «щелчок» и знак направления.
+// Горизонтальные направления дают 0 — скролбэк одномерный, крутить вбок нечего.
+const WHEEL_SCROLL_LINES = 3;
+const WHEEL_SCROLL_SIGN = { up: -1, down: 1, left: 0, right: 0 };
+export class TerminalViewElement extends TUIElement {
+    surface;
+    // Переиспользуемая ячейка — readCell(x, y, cell) не аллоцирует новый объект на каждую ячейку.
+    cell = { char: " ", fg: DEFAULT_COLOR, bg: DEFAULT_COLOR, style: 0, width: 1 };
+    // Подписки на поверхность — TUIElement не имеет lifecycle-хука, поэтому храним их сами
+    // и рвём в dispose() (владелец виджета — контроллер — обязан его вызвать).
+    subscriptions = [];
+    // Цвета «по умолчанию», которыми заменяем DEFAULT_COLOR ячеек при блите. Контроллер
+    // пушит сюда цвета темы (как EditorElement/PanelContainerElement получают цвета извне).
+    constructor(surface) {
+        super();
+        // Дефолтные цвета терминала — токены темы (фоллбэки panel/editor — в пуше палитры).
+        this.style = { fg: "terminal.foreground", bg: "terminal.background" };
+        this.surface = surface;
+        this.focusable = true; // фокусируемый — принимает клавиатуру
+        this.capturesPointer = true; // drag: move/up приходят сюда даже вне границ
+        // Новые данные из шелла → перерисовать контрол (TuiApplication батчит кадр).
+        this.subscriptions.push(this.surface.onUpdate(() => {
+            this.markDirty();
+        }));
+        // Выход шелла тоже перерисовывает — чтобы спрятать курсор (isExited в render).
+        this.subscriptions.push(this.surface.onExit(() => {
+            this.markDirty();
+        }));
+        // Мышь → surface (эмулятор сам решает по активному mouse-режиму, слать ли отчёт).
+        this.addEventListener("mousedown", (event) => {
+            this.forwardMouse(event, "down");
+        });
+        this.addEventListener("mouseup", (event) => {
+            this.forwardMouse(event, "up");
+        });
+        this.addEventListener("mousemove", (event) => {
+            this.forwardMouse(event, "move");
+        });
+        this.addEventListener("wheel", (event) => {
+            const mouse = event;
+            // Колесо без направления (бэкенд его не распознал) трактуем как прокрутку вверх.
+            const direction = mouse.wheelDirection ?? "up";
+            // Программа включила mouse-tracking (htop/vim/less --mouse) — колесо её,
+            // отдаём отчёт как есть. Обычный шелл mouse-режимов не включает, и тогда
+            // колесо наше: крутим вьюпорт по скролбэку (как xterm.js/VS Code).
+            if (this.surface.mouseEventsActive) {
+                this.sendMouse(mouse, "wheel", WHEEL_ACTION[direction]);
+                return;
+            }
+            const sign = WHEEL_SCROLL_SIGN[direction];
+            if (sign === 0)
+                return;
+            mouse.preventDefault();
+            this.surface.scrollLines(sign * WHEEL_SCROLL_LINES);
+        });
+    }
+    /** Рвёт подписки на поверхность. Вызывается владельцем виджета (контроллером). */
+    dispose() {
+        for (const sub of this.subscriptions)
+            sub.dispose();
+        this.subscriptions.length = 0;
+    }
+    forwardMouse(event, action) {
+        this.sendMouse(event, event.button, action);
+    }
+    sendMouse(event, button, action) {
+        this.surface.sendMouse({
+            col: event.localX,
+            row: event.localY,
+            button,
+            action,
+            ctrl: event.ctrlKey,
+            alt: event.altKey,
+            shift: event.shiftKey,
+        });
+    }
+    performLayout(constraints) {
+        const size = super.performLayout(constraints);
+        // Держим PTY и эмулятор ровно по выделенной области (TIOCSWINSZ+SIGWINCH).
+        this.surface.resize(size.width, size.height);
+        return size;
+    }
+    render(context) {
+        const width = this.layoutSize.width;
+        const height = this.layoutSize.height;
+        const cell = this.cell;
+        for (let y = 0; y < height; y++) {
+            // readCell отдаёт false и для continuation-ячейки wide-char, и для координаты
+            // вне диапазона. Различаем по предыдущей ячейке: после width=2 следующий false —
+            // это continuation (голова уже нарисована с шириной 2), пропускаем без покраски;
+            // иначе это пустая/внедиапазонная ячейка — красим пробелом, чтобы область виджета
+            // была закрашена полностью.
+            let prevWasWide = false;
+            for (let x = 0; x < width; x++) {
+                if (this.surface.readCell(x, y, cell)) {
+                    context.setCell(x, y, {
+                        char: cell.char,
+                        fg: cell.fg === DEFAULT_COLOR ? this.resolvedStyle.fg : cell.fg,
+                        bg: cell.bg === DEFAULT_COLOR ? this.resolvedStyle.bg : cell.bg,
+                        style: cell.style,
+                        width: cell.width,
+                    });
+                    prevWasWide = cell.width === 2;
+                }
+                else if (prevWasWide) {
+                    prevWasWide = false; // continuation wide-char — пропускаем
+                }
+                else {
+                    context.setCell(x, y, { char: " " }); // пустая/вне диапазона
+                }
+            }
+        }
+        // Курсор PTY показываем только когда контрол в фокусе и шелл жив.
+        if (this.isFocused && !this.surface.isExited) {
+            const cursor = this.surface.getCursor();
+            if (cursor !== null && cursor.x >= 0 && cursor.x < width && cursor.y >= 0 && cursor.y < height) {
+                context.setCursorPosition(cursor.x, cursor.y);
+            }
+        }
+    }
+    performDefaultAction(event) {
+        if (event.type === "paste") {
+            event.preventDefault();
+            this.surface.write(event.text);
+            return;
+        }
+        if (event.type === "keydown") {
+            const key = event;
+            // Shift+PageUp/PageDown — клавиатурный аналог колеса: листаем скролбэк
+            // страницами, в PTY эти сочетания не уходят.
+            if (key.shiftKey && (key.key === "PageUp" || key.key === "PageDown")) {
+                event.preventDefault();
+                const page = Math.max(1, this.layoutSize.height - 1);
+                this.surface.scrollLines(key.key === "PageUp" ? -page : page);
+                return;
+            }
+            const bytes = encodeKeyForPty(key);
+            if (bytes !== "") {
+                event.preventDefault();
+                this.surface.write(bytes);
+            }
+            return;
+        }
+        // Всё остальное (в т.ч. mousedown) → базовое поведение: клик по фокусируемому
+        // элементу переводит на него фокус (TUIElement.performDefaultAction).
+        super.performDefaultAction(event);
+    }
+}

package/dist/text/textBlockElement.d.ts

@@ -0,0 +1,13 @@
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+import type { IContentSized } from "../scrollbar/iScrollable.js";
+export declare class TextBlockElement extends TUIElement implements IContentSized {
+    contentHeight: number;
+    contentWidth: number;
+    private lines;
+    constructor(lineCount: number);
+    getMinIntrinsicWidth(_height: number): number;
+    getMaxIntrinsicWidth(_height: number): number;
+    getMinIntrinsicHeight(_width: number): number;
+    getMaxIntrinsicHeight(_width: number): number;
+    render(context: RenderContext): void;
+}

package/dist/text/textBlockElement.js

@@ -0,0 +1,35 @@
+import { DisplayLine } from "@tuidom/core/common/displayLine";
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+export class TextBlockElement extends TUIElement {
+    contentHeight;
+    contentWidth;
+    lines;
+    constructor(lineCount) {
+        super();
+        this.contentHeight = lineCount;
+        this.lines = [];
+        for (let i = 0; i < lineCount; i++) {
+            this.lines.push(`Line ${String(i + 1).padStart(3, "0")}`);
+        }
+        this.contentWidth = this.lines.reduce((max, l) => Math.max(max, new DisplayLine(l).displayWidth), 0);
+    }
+    getMinIntrinsicWidth(_height) {
+        return this.contentWidth;
+    }
+    getMaxIntrinsicWidth(_height) {
+        return this.contentWidth;
+    }
+    getMinIntrinsicHeight(_width) {
+        return this.contentHeight;
+    }
+    getMaxIntrinsicHeight(_width) {
+        return this.contentHeight;
+    }
+    render(context) {
+        const width = this.layoutSize.width;
+        for (let y = 0; y < this.contentHeight; y++) {
+            const lineContent = y < this.lines.length ? this.lines[y] : "";
+            context.drawText(0, y, lineContent, undefined, { maxWidth: width });
+        }
+    }
+}

package/dist/text/textLabelElement.d.ts

@@ -0,0 +1,28 @@
+import { BoxConstraints, Size } from "@tuidom/core/common/geometryPromitives";
+import { StyleFlags } from "@tuidom/core/common/styleFlags";
+import type { StyleColor } from "@tuidom/core/dom/styles/tuiStyle";
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+/** Посимвольный стиль; цвета — StyleColor: числа ИЛИ имена токенов темы. */
+export interface StyledChar {
+    fg?: StyleColor;
+    bg?: StyleColor;
+    style?: StyleFlags;
+}
+export declare class TextLabelElement extends TUIElement {
+    private text;
+    private charStyles;
+    private cachedDisplayLine;
+    constructor(text: string);
+    private get displayLine();
+    getText(): string;
+    setText(text: string): void;
+    setColors(fg: StyleColor, bg: StyleColor): void;
+    setCharStyle(index: number, charStyle: StyledChar): void;
+    clearCharStyles(): void;
+    getMinIntrinsicWidth(_height: number): number;
+    getMaxIntrinsicWidth(_height: number): number;
+    getMinIntrinsicHeight(_width: number): number;
+    getMaxIntrinsicHeight(_width: number): number;
+    protected performLayout(constraints: BoxConstraints): Size;
+    render(context: RenderContext): void;
+}

package/dist/text/textLabelElement.js

@@ -0,0 +1,77 @@
+import { DisplayLine } from "@tuidom/core/common/displayLine";
+import { BoxConstraints, Size } from "@tuidom/core/common/geometryPromitives";
+import { StyleFlags } from "@tuidom/core/common/styleFlags";
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+export class TextLabelElement extends TUIElement {
+    text;
+    charStyles = new Map();
+    // Сегментация — O(длины текста) на каждое построение DisplayLine, а лейбл
+    // строил его дважды за кадр (layout + render). Кэш живёт до setText;
+    // charStyles/цвета на текст не влияют и кэш не трогают.
+    cachedDisplayLine = null;
+    constructor(text) {
+        super();
+        this.text = text;
+    }
+    get displayLine() {
+        return (this.cachedDisplayLine ??= new DisplayLine(this.text));
+    }
+    getText() {
+        return this.text;
+    }
+    setText(text) {
+        this.text = text;
+        this.cachedDisplayLine = null;
+        this.markDirty();
+    }
+    setColors(fg, bg) {
+        this.style = { ...this.style, fg, bg };
+    }
+    setCharStyle(index, charStyle) {
+        this.charStyles.set(index, charStyle);
+        this.markDirty();
+    }
+    clearCharStyles() {
+        this.charStyles.clear();
+        this.markDirty();
+    }
+    getMinIntrinsicWidth(_height) {
+        return this.displayLine.displayWidth;
+    }
+    getMaxIntrinsicWidth(_height) {
+        return this.displayLine.displayWidth;
+    }
+    getMinIntrinsicHeight(_width) {
+        return 1;
+    }
+    getMaxIntrinsicHeight(_width) {
+        return 1;
+    }
+    performLayout(constraints) {
+        const natural = new Size(this.getMaxIntrinsicWidth(1), this.getMaxIntrinsicHeight(0));
+        return super.performLayout(BoxConstraints.tight(constraints.constrain(natural)));
+    }
+    render(context) {
+        const width = this.layoutSize.width;
+        const resolved = this.resolvedStyle;
+        context.drawText(0, 0, this.text, { fg: resolved.fg, bg: resolved.bg, style: StyleFlags.None }, {
+            maxWidth: width,
+            displayLine: this.displayLine,
+            getStyle: (offset) => {
+                const charStyle = this.charStyles.get(offset);
+                if (charStyle === undefined)
+                    return undefined;
+                // Ключи — только для заданных полей: drawText мёржит
+                // спредом, и ключ с undefined затёр бы базовый цвет.
+                const override = {};
+                if (charStyle.fg !== undefined)
+                    override.fg = this.resolveColor(charStyle.fg);
+                if (charStyle.bg !== undefined)
+                    override.bg = this.resolveColor(charStyle.bg);
+                if (charStyle.style !== undefined)
+                    override.style = charStyle.style;
+                return override;
+            },
+        });
+    }
+}

package/dist/titledpanel/titledPanelElement.d.ts

@@ -0,0 +1,14 @@
+import { BoxConstraints, Size } from "@tuidom/core/common/geometryPromitives";
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+export declare class TitledPanelElement extends TUIElement {
+    private title;
+    private child;
+    private titlePaddingLeft;
+    constructor(title: string, child: TUIElement, options?: {
+        titlePaddingLeft?: number;
+    });
+    getTitle(): string;
+    setTitle(value: string): void;
+    protected performLayout(constraints: BoxConstraints): Size;
+    render(context: RenderContext): void;
+}

package/dist/titledpanel/titledPanelElement.js

@@ -0,0 +1,40 @@
+import { BoxConstraints, Size } from "@tuidom/core/common/geometryPromitives";
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+export class TitledPanelElement extends TUIElement {
+    title;
+    child;
+    titlePaddingLeft;
+    constructor(title, child, options) {
+        super();
+        this.title = title;
+        this.child = child;
+        this.appendChild(this.child);
+        this.titlePaddingLeft = options?.titlePaddingLeft ?? 1;
+    }
+    getTitle() {
+        return this.title;
+    }
+    setTitle(value) {
+        this.title = value;
+        this.markDirty();
+    }
+    performLayout(constraints) {
+        const containerSize = super.performLayout(constraints);
+        const childHeight = Math.max(0, containerSize.height - 1);
+        this.layoutChild(this.child, 0, 1, BoxConstraints.tight(new Size(containerSize.width, childHeight)));
+        return containerSize;
+    }
+    render(context) {
+        this.paintOwnBackground(context);
+        const width = this.layoutSize.width;
+        const resolved = this.resolvedStyle;
+        const titleFg = this.styleVar("titledPanel.titleForeground");
+        const titleBg = resolved.bg;
+        for (let x = 0; x < width; x++) {
+            const textIndex = x - this.titlePaddingLeft;
+            const char = textIndex >= 0 && textIndex < this.title.length ? this.title[textIndex] : " ";
+            context.setCell(x, 0, { char, fg: titleFg, bg: titleBg });
+        }
+        this.renderChildren(context);
+    }
+}

package/dist/tree/iTreeDataProvider.d.ts

@@ -0,0 +1,19 @@
+import type { StyleColor } from "@tuidom/core/dom/styles/tuiStyle";
+export interface ITreeItem {
+    readonly label: string;
+    readonly icon?: string;
+    readonly iconColor?: StyleColor;
+    readonly collapsible: boolean;
+    /** Помечает элемент как символическую ссылку: рисуется стрелка-badge у левого края. */
+    readonly symlink?: boolean;
+    /** Буква-бейдж статуса (1–2 символа), рисуется у правого края строки (напр. git-статус). */
+    readonly badge?: string;
+    /** Упакованный RGB-цвет имени: переопределяет fg спана метки (напр. git-статус). */
+    readonly labelColor?: StyleColor;
+}
+export interface ITreeDataProvider<T> {
+    getTreeItem(element: T): ITreeItem;
+    getChildren(element?: T): T[] | Promise<T[]>;
+    getKey(element: T): string;
+    onChange?: (element?: T) => void;
+}

package/dist/tree/iTreeDataProvider.js

@@ -0,0 +1 @@
+export {};

package/dist/tree/treeViewElement.d.ts

@@ -0,0 +1,116 @@
+import { Point } from "@tuidom/core/common/geometryPromitives";
+import type { TUIEventBase } from "@tuidom/core/dom/events/tuiEventBase";
+import type { RenderContext } from "@tuidom/core/dom/tuiElement";
+import { ScrollableElement, type ScrollViewportInfo } from "../scrollbar/scrollableElement.js";
+import type { ITreeDataProvider } from "./iTreeDataProvider.js";
+export declare class TreeViewElement<T> extends ScrollableElement {
+    private provider;
+    private expandedKeys;
+    private childrenCache;
+    private flatNodes;
+    private selectedIndex;
+    private selectionAnchor;
+    private hoveredIndex;
+    private selectedKeys;
+    private cutKeys;
+    private maxRowWidth;
+    /**
+     * Отступ контента строк от левого края элемента. В отличие от внешнего
+     * паддинг-контейнера, входит в саму строку, поэтому фон курсора/выделения
+     * заливает строку от края, а текст начинается со сдвигом.
+     */
+    private leftPadding;
+    private typeaheadBuffer;
+    private typeaheadTimer;
+    onSelect: ((item: T) => void) | null;
+    onActivate: ((item: T) => void) | null;
+    onExpandedChanged: ((element: T, expanded: boolean) => void) | null;
+    onContextMenu: ((element: T, screenX: number, screenY: number) => void) | null;
+    constructor(provider: ITreeDataProvider<T>, options?: {
+        leftPadding?: number;
+    });
+    get contentHeight(): number;
+    get contentWidth(): number;
+    refresh(element?: T): Promise<void>;
+    toggleExpand(element: T): Promise<void>;
+    /** Раскрывает узел (идемпотентно, без прокрутки/выделения) и перестраивает список. */
+    expand(element: T): Promise<void>;
+    /** Раскрывает узел (загружая детей в кеш), если он ещё не раскрыт. No-op для уже раскрытого. */
+    private expandElement;
+    /**
+     * Раскрывает цепочку предков и ставит курсор на целевой узел, проматывая к нему.
+     * `chain` — путь от корня к цели включительно: все элементы кроме последнего
+     * трактуются как предки-контейнеры и раскрываются, последний — цель выделения.
+     * Если цель не находится в дереве после раскрытия (например, путь вне корня),
+     * выделение не меняется.
+     */
+    reveal(chain: T[]): Promise<void>;
+    setCutKeys(keys: Set<string>): void;
+    clearCutKeys(): void;
+    /** Узел под курсором, либо null если дерево пусто. */
+    getSelectedNode(): T | null;
+    /**
+     * Глобальные экранные координаты выделенной строки — якорь для контекстного меню,
+     * открытого с клавиатуры (Shift+F10). X сдвинут на отступ по глубине узла, чтобы
+     * меню появлялось у имени, а не у левого края панели. Возвращает `null`, если
+     * дерево пусто.
+     */
+    getSelectedRowGlobalPosition(): Point | null;
+    /**
+     * Все выбранные узлы. Если множественный выбор пуст, возвращает узел под курсором
+     * (в виде массива из одного элемента). Порядок — как в дереве.
+     */
+    getSelectedNodes(): T[];
+    protected performDefaultAction(event: TUIEventBase): void;
+    protected renderViewport(context: RenderContext, viewport: ScrollViewportInfo): void;
+    private resolveRowColors;
+    private loadRootChildren;
+    private reloadExpandedChildren;
+    private invalidateSubtreeCache;
+    private rebuildFlatList;
+    private appendChildren;
+    /** Колонка (в координатах контента), с которой начинается строка узла данной глубины. */
+    private rowIndentX;
+    private calculateRowWidth;
+    private formatRow;
+    private getSelectedKey;
+    private restoreSelection;
+    focusPageDown(): void;
+    focusPageUp(): void;
+    focusFirst(): void;
+    focusLast(): void;
+    private setSelectedIndex;
+    /** Двигает курсор и расширяет множественный выбор диапазоном от якоря (Shift+стрелки). */
+    private extendSelectionTo;
+    private selectRange;
+    /** Переключает выбор одной строки (Ctrl/Cmd+клик), не сбрасывая остальное. */
+    private toggleSelectionAt;
+    private applyCursor;
+    private ensureVisible;
+    private findElementByKey;
+    private handleKeypress;
+    /**
+     * Быстрый поиск по набору: печатаешь символы — курсор перепрыгивает к первому узлу,
+     * чья метка начинается с набранной последовательности. Повтор одного и того же
+     * символа циклически перебирает совпадения; набор из разных символов уточняет
+     * префикс, начиная с текущей строки. Буфер копится, пока не выйдет тайм-аут.
+     */
+    private handleTypeahead;
+    private restartTypeaheadTimer;
+    private jumpToTypeaheadMatch;
+    private handleExpandOrMoveToChild;
+    private handleCollapseOrMoveToParent;
+    private activateSelected;
+    private toggleSelected;
+    /**
+     * Единый вход контекстного меню: от мыши — узел под кликом (мультивыбор по
+     * выбранной строке не сбрасывается), от клавиатуры — узел курсора с якорем
+     * на его глобальной позиции. Виджет только сигналит {@link onContextMenu}.
+     */
+    private handleContextMenu;
+    private handleClick;
+    private handleDblClick;
+    private handleMouseMove;
+    private handleMouseLeave;
+    private handleWheel;
+}