@tuidom/elements 0.1.0

package/dist/body/bodyElement.d.ts

@@ -0,0 +1,33 @@
+import { BoxConstraints, Size } from "@tuidom/core/common/geometryPromitives";
+import { OverlayLayer } from "@tuidom/core/dom/overlayLayer";
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+export declare class BodyElement extends TUIElement {
+    private titleValue;
+    readonly overlayLayer: OverlayLayer;
+    get title(): string;
+    set title(value: string);
+    private readonly vflex;
+    /**
+     * Держит место контента, пока тот не задан: без fill-ряда между menuBar и
+     * statusBar статус-бар прилипал бы к верху, а не к нижнему ряду. Ничего не
+     * рисует (дефолтный render пустого элемента).
+     */
+    private readonly contentSpacer;
+    private menuBar;
+    private content;
+    private statusBar;
+    constructor();
+    getOverlayLayer(): OverlayLayer;
+    setContent(element: TUIElement): void;
+    /** Слот занимает ровно 1 ряд — виджет, рисующий ниже ряда 0, будет обрезан. */
+    setMenuBar(menuBar: TUIElement | null): void;
+    /** Слот занимает ровно 1 ряд — виджет, рисующий ниже ряда 0, будет обрезан. */
+    setStatusBar(statusBar: TUIElement | null): void;
+    /**
+     * Пересобирает ряды vflex в каноническом порядке слотов: menuBar (1 ряд),
+     * content (остаток), statusBar (1 ряд).
+     */
+    private syncSlots;
+    protected performLayout(constraints: BoxConstraints): Size;
+    render(context: RenderContext): void;
+}

package/dist/body/bodyElement.js

@@ -0,0 +1,87 @@
+import { BoxConstraints, Size } from "@tuidom/core/common/geometryPromitives";
+import { OverlayLayer } from "@tuidom/core/dom/overlayLayer";
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+import { VFlexElement, vflexFill, vflexFixed } from "../layout/vFlexElement.js";
+export class BodyElement extends TUIElement {
+    titleValue = "";
+    overlayLayer;
+    get title() {
+        return this.titleValue;
+    }
+    set title(value) {
+        if (value === this.titleValue)
+            return;
+        this.titleValue = value;
+        // Заголовок — paint-состояние: кадр ввода рендерится только по
+        // dirty-флагу, мутация обязана помечать его сама.
+        this.markDirty();
+    }
+    vflex = new VFlexElement();
+    /**
+     * Держит место контента, пока тот не задан: без fill-ряда между menuBar и
+     * statusBar статус-бар прилипал бы к верху, а не к нижнему ряду. Ничего не
+     * рисует (дефолтный render пустого элемента).
+     */
+    contentSpacer = new TUIElement();
+    menuBar = null;
+    content = null;
+    statusBar = null;
+    constructor() {
+        super();
+        // BodyElement is the root, so mark it as such
+        this.setAsRoot();
+        this.overlayLayer = new OverlayLayer();
+        // Дети body неизменны; порядок — это z-порядок хит-теста:
+        // overlay последний, т.е. поверх всего.
+        this.setChildren([this.vflex, this.overlayLayer]);
+    }
+    getOverlayLayer() {
+        return this.overlayLayer;
+    }
+    setContent(element) {
+        this.content = element;
+        this.syncSlots();
+    }
+    /** Слот занимает ровно 1 ряд — виджет, рисующий ниже ряда 0, будет обрезан. */
+    setMenuBar(menuBar) {
+        this.menuBar = menuBar;
+        this.syncSlots();
+    }
+    /** Слот занимает ровно 1 ряд — виджет, рисующий ниже ряда 0, будет обрезан. */
+    setStatusBar(statusBar) {
+        this.statusBar = statusBar;
+        this.syncSlots();
+    }
+    /**
+     * Пересобирает ряды vflex в каноническом порядке слотов: menuBar (1 ряд),
+     * content (остаток), statusBar (1 ряд).
+     */
+    syncSlots() {
+        const rows = [];
+        if (this.menuBar) {
+            this.menuBar.layoutStyle = { height: vflexFixed(1), width: "fill" };
+            rows.push(this.menuBar);
+        }
+        const contentRow = this.content ?? this.contentSpacer;
+        contentRow.layoutStyle = { height: vflexFill(), width: "fill" };
+        rows.push(contentRow);
+        if (this.statusBar) {
+            this.statusBar.layoutStyle = { height: vflexFixed(1), width: "fill" };
+            rows.push(this.statusBar);
+        }
+        this.vflex.replaceChildren(rows);
+    }
+    performLayout(constraints) {
+        const containerSize = super.performLayout(constraints);
+        this.layoutChild(this.vflex, 0, 0, BoxConstraints.tight(containerSize));
+        this.layoutChild(this.overlayLayer, 0, 0, BoxConstraints.tight(containerSize));
+        return containerSize;
+    }
+    render(context) {
+        // Title (legacy behaviour)
+        for (let y = 0; y < this.title.length; y++) {
+            context.setCell(y, 0, { char: this.title[y] });
+        }
+        this.renderChildren(context);
+    }
+}

package/dist/button/buttonElement.d.ts

@@ -0,0 +1,18 @@
+import { BoxConstraints, Size } from "@tuidom/core/common/geometryPromitives";
+import type { TUIEventBase } from "@tuidom/core/dom/events/tuiEventBase";
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+export declare class ButtonElement extends TUIElement {
+    onActivate?: () => void;
+    private readonly label;
+    constructor(label: string);
+    getLabel(): string;
+    /** Режим «включённого тумблера» (кнопки-переключатели поиска): primary-вид. */
+    setChecked(checked: boolean): void;
+    getMinIntrinsicWidth(_height: number): number;
+    getMaxIntrinsicWidth(_height: number): number;
+    getMinIntrinsicHeight(_width: number): number;
+    getMaxIntrinsicHeight(_width: number): number;
+    protected performLayout(constraints: BoxConstraints): Size;
+    protected performDefaultAction(event: TUIEventBase): void;
+    render(context: RenderContext): void;
+}

package/dist/button/buttonElement.js

@@ -0,0 +1,68 @@
+import { BoxConstraints, Size } from "@tuidom/core/common/geometryPromitives";
+import { TUIKeyboardEvent } from "@tuidom/core/dom/events/tuiKeyboardEvent";
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+export class ButtonElement extends TUIElement {
+    onActivate;
+    label;
+    constructor(label) {
+        super();
+        this.label = label;
+        this.focusable = true;
+        // Вся state-логика цвета — в when-вариантах: hover/focus ставит ядро,
+        // "checked" (тумблеры) — setChecked. Порядок = приоритет: checked
+        // объявлен ПОСЛЕ focus — включённый тумблер выглядит primary
+        // независимо от фокуса.
+        this.style = {
+            fg: "button.secondaryForeground",
+            bg: "button.secondaryBackground",
+            when: [
+                { states: ["hover"], bg: "button.secondaryHoverBackground" },
+                { states: ["focus"], fg: "button.foreground", bg: "button.background" },
+                { states: ["focus", "hover"], bg: "button.hoverBackground" },
+                { states: ["checked"], fg: "button.foreground", bg: "button.background" },
+                { states: ["checked", "hover"], bg: "button.hoverBackground" },
+            ],
+        };
+        this.addEventListener("click", (event) => {
+            if (event.defaultPrevented)
+                return;
+            this.onActivate?.();
+        });
+    }
+    getLabel() {
+        return this.label;
+    }
+    /** Режим «включённого тумблера» (кнопки-переключатели поиска): primary-вид. */
+    setChecked(checked) {
+        this.setStyleState("checked", checked);
+    }
+    getMinIntrinsicWidth(_height) {
+        return this.label.length + 4;
+    }
+    getMaxIntrinsicWidth(_height) {
+        return this.label.length + 4;
+    }
+    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)));
+    }
+    performDefaultAction(event) {
+        if (event.type !== "keydown")
+            return;
+        const keyEvent = event;
+        if (keyEvent.key === "Enter" || keyEvent.key === " ") {
+            event.preventDefault();
+            this.onActivate?.();
+        }
+    }
+    render(context) {
+        const { fg, bg } = this.resolvedStyle;
+        context.drawText(0, 0, `[ ${this.label} ]`, { fg, bg }, { maxWidth: this.layoutSize.width });
+    }
+}

package/dist/completionlist/completionDetailsElement.d.ts

@@ -0,0 +1,49 @@
+import { BoxConstraints, Size } from "@tuidom/core/common/geometryPromitives";
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+/** Содержимое панели: сигнатура сверху, документация под ней. */
+export interface CompletionDetailsContent {
+    /** Сигнатура/тип пункта (`detail` или `labelDetails.detail`). */
+    readonly detail?: string;
+    /** Документация пункта. Markdown НЕ парсится — рендерера markdown нет. */
+    readonly documentation?: string;
+}
+/**
+ * Панель описания выбранного пункта автодополнения — соседка
+ * {@link import("./completionListElement.js").CompletionListElement} в
+ * {@link import("./completionWidgetElement.js").CompletionWidgetElement}.
+ *
+ * Показывает сигнатуру и документацию с переносом по словам. Содержимое
+ * приходит извне уже догруженным (у LSP-источников описание доезжает отдельным
+ * `resolve`-запросом), сама панель ничего не запрашивает. Фокус не забирает —
+ * как и список, живёт при активном редакторе.
+ */
+export declare class CompletionDetailsElement extends TUIElement {
+    /** Предельная ширина панели; высоту ограничивает владелец по высоте списка. */
+    maxWidth: number;
+    maxHeight: number;
+    private detailValue;
+    private documentationValue;
+    /** Кэш переноса: (ширина текста) → строки. Layout зовут на каждый кадр. */
+    private wrapCache;
+    constructor();
+    /** Есть ли что показывать (пустая панель не занимает места). */
+    get isEmpty(): boolean;
+    setContent(content: CompletionDetailsContent | null): void;
+    /** Строки контента после переноса — для тестов и измерения. */
+    linesFor(textWidth: number): readonly string[];
+    private get textWidth();
+    private get boxWidth();
+    private get boxHeight();
+    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;
+}
+/**
+ * Перенос по словам в ширину `width`. Переводы строк источника сохраняются;
+ * слово длиннее строки режется по ширине (усечения контента не происходит —
+ * остаток уезжает на следующую строку).
+ */
+export declare function wrapText(text: string, width: number): string[];

package/dist/completionlist/completionDetailsElement.js

@@ -0,0 +1,165 @@
+import { DisplayLine } from "@tuidom/core/common/displayLine";
+import { BoxConstraints, Size } from "@tuidom/core/common/geometryPromitives";
+import { truncateEnd } from "@tuidom/core/common/textTruncation";
+import { BORDER_THICKNESS } from "@tuidom/core/dom/borderStyle";
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+// ─── Layout ───────────────────────────────────────────────────────────────────
+// [│(0)][pad(1)][текст…][pad(w-2)][│(w-1)]
+const TEXT_X = 2;
+const RIGHT_PAD = 1;
+const MIN_WIDTH = 20;
+const DEFAULT_MAX_WIDTH = 60;
+/**
+ * Панель описания выбранного пункта автодополнения — соседка
+ * {@link import("./completionListElement.ts").CompletionListElement} в
+ * {@link import("./completionWidgetElement.ts").CompletionWidgetElement}.
+ *
+ * Показывает сигнатуру и документацию с переносом по словам. Содержимое
+ * приходит извне уже догруженным (у LSP-источников описание доезжает отдельным
+ * `resolve`-запросом), сама панель ничего не запрашивает. Фокус не забирает —
+ * как и список, живёт при активном редакторе.
+ */
+export class CompletionDetailsElement extends TUIElement {
+    /** Предельная ширина панели; высоту ограничивает владелец по высоте списка. */
+    maxWidth = DEFAULT_MAX_WIDTH;
+    maxHeight = 10;
+    detailValue = "";
+    documentationValue = "";
+    /** Кэш переноса: (ширина текста) → строки. Layout зовут на каждый кадр. */
+    wrapCache = null;
+    constructor() {
+        super();
+        this.focusable = false;
+    }
+    /** Есть ли что показывать (пустая панель не занимает места). */
+    get isEmpty() {
+        return this.detailValue === "" && this.documentationValue === "";
+    }
+    setContent(content) {
+        const detail = content?.detail ?? "";
+        const documentation = content?.documentation ?? "";
+        if (detail === this.detailValue && documentation === this.documentationValue)
+            return;
+        this.detailValue = detail;
+        this.documentationValue = documentation;
+        this.wrapCache = null;
+        this.markDirty();
+    }
+    /** Строки контента после переноса — для тестов и измерения. */
+    linesFor(textWidth) {
+        if (this.wrapCache !== null && this.wrapCache.width === textWidth)
+            return this.wrapCache.lines;
+        const lines = [];
+        if (this.detailValue !== "")
+            lines.push(...wrapText(this.detailValue, textWidth));
+        // Пустая строка-разделитель нужна, только если есть обе части.
+        if (this.detailValue !== "" && this.documentationValue !== "")
+            lines.push("");
+        if (this.documentationValue !== "")
+            lines.push(...wrapText(this.documentationValue, textWidth));
+        this.wrapCache = { width: textWidth, lines };
+        return lines;
+    }
+    // ─── Sizing ──────────────────────────────────────────────────────────────
+    get textWidth() {
+        const natural = Math.max(naturalWidth(this.detailValue), naturalWidth(this.documentationValue), MIN_WIDTH - TEXT_X - RIGHT_PAD - BORDER_THICKNESS);
+        return Math.min(natural, this.maxWidth - TEXT_X - RIGHT_PAD - BORDER_THICKNESS);
+    }
+    get boxWidth() {
+        if (this.isEmpty)
+            return 0;
+        return TEXT_X + this.textWidth + RIGHT_PAD + BORDER_THICKNESS;
+    }
+    get boxHeight() {
+        if (this.isEmpty)
+            return 0;
+        const lines = this.linesFor(this.textWidth).length;
+        return Math.min(this.maxHeight, lines + BORDER_THICKNESS * 2);
+    }
+    getMinIntrinsicWidth(_height) {
+        return this.boxWidth;
+    }
+    getMaxIntrinsicWidth(_height) {
+        return this.boxWidth;
+    }
+    getMinIntrinsicHeight(_width) {
+        return this.boxHeight;
+    }
+    getMaxIntrinsicHeight(_width) {
+        return this.boxHeight;
+    }
+    performLayout(constraints) {
+        const size = constraints.constrain(new Size(this.boxWidth, this.boxHeight));
+        super.performLayout(BoxConstraints.tight(size));
+        return size;
+    }
+    // ─── Render ──────────────────────────────────────────────────────────────
+    render(context) {
+        if (this.isEmpty)
+            return;
+        const w = this.layoutSize.width;
+        const h = this.layoutSize.height;
+        if (w <= 0 || h <= 0)
+            return;
+        context.drawBox(0, 0, w, h, {
+            fg: this.styleVar("editorSuggestWidget.border"),
+            bg: this.styleVar("editorSuggestWidget.background"),
+            fill: true,
+        });
+        const textWidth = Math.max(0, w - TEXT_X - RIGHT_PAD - BORDER_THICKNESS);
+        const lines = this.linesFor(textWidth);
+        const visible = Math.min(lines.length, Math.max(0, h - BORDER_THICKNESS * 2));
+        const detailLines = this.detailValue === "" ? 0 : wrapText(this.detailValue, textWidth).length;
+        for (let i = 0; i < visible; i++) {
+            // Сигнатура сверху — приглушённым цветом, как в правой колонке списка.
+            const isDetail = i < detailLines;
+            context.drawText(TEXT_X, BORDER_THICKNESS + i, lines[i], {
+                fg: this.styleVar(isDetail ? "editorSuggestWidget.detailForeground" : "editorSuggestWidget.foreground"),
+                bg: this.styleVar("editorSuggestWidget.background"),
+            }, { maxWidth: textWidth });
+        }
+    }
+}
+/** Ширина самой длинной строки текста как есть (до переноса). */
+function naturalWidth(text) {
+    let max = 0;
+    for (const line of text.split("\n"))
+        max = Math.max(max, new DisplayLine(line).displayWidth);
+    return max;
+}
+/**
+ * Перенос по словам в ширину `width`. Переводы строк источника сохраняются;
+ * слово длиннее строки режется по ширине (усечения контента не происходит —
+ * остаток уезжает на следующую строку).
+ */
+export function wrapText(text, width) {
+    if (width <= 0)
+        return [];
+    const result = [];
+    for (const paragraph of text.split("\n")) {
+        let current = "";
+        for (const word of paragraph.split(/\s+/).filter((w) => w !== "")) {
+            const candidate = current === "" ? word : `${current} ${word}`;
+            if (new DisplayLine(candidate).displayWidth <= width) {
+                current = candidate;
+                continue;
+            }
+            if (current !== "")
+                result.push(current);
+            // Слово шире строки: режем его по ширине, пока помещается остаток.
+            let rest = word;
+            while (new DisplayLine(rest).displayWidth > width) {
+                const head = truncateEnd(rest, width, "");
+                // Символ шире строки (широкий CJK при width 1) — усечение даёт
+                // пустую строку; режем принудительно, иначе цикл вечный.
+                if (head === "")
+                    break;
+                result.push(head);
+                rest = rest.slice(head.length);
+            }
+            current = rest;
+        }
+        result.push(current);
+    }
+    return result;
+}

package/dist/completionlist/completionItemKindIcon.d.ts

@@ -0,0 +1,2 @@
+/** Возвращает codicon-глиф для `CompletionItemKind` (fallback — дефолтный). */
+export declare function kindIcon(kind: number | undefined): string;

package/dist/completionlist/completionItemKindIcon.js

@@ -0,0 +1,43 @@
+/**
+ * Иконки для `CompletionItemKind` (числовые значения enum VS Code 0…26) —
+ * codicon-глифы (Private Use Area), как в nvim-cmp / lspkind preset "codicons".
+ * Требует nerd-font (со встроенными codicon'ами) в терминале.
+ *
+ * TUIDom-локальный, без зависимостей от Editor/Extensions — принимает сырое
+ * число `kind`.
+ */
+const KIND_ICONS = {
+    0: "", // Text
+    1: "", // Method
+    2: "", // Function
+    3: "", // Constructor
+    4: "", // Field
+    5: "", // Variable
+    6: "", // Class
+    7: "", // Interface
+    8: "", // Module
+    9: "", // Property
+    10: "", // Unit
+    11: "", // Value
+    12: "", // Enum
+    13: "", // Keyword
+    14: "", // Snippet
+    15: "", // Color
+    16: "", // File
+    17: "", // Reference
+    18: "", // Folder
+    19: "", // EnumMember
+    20: "", // Constant
+    21: "", // Struct
+    22: "", // Event
+    23: "", // Operator
+    24: "", // TypeParameter
+};
+/** Иконка по умолчанию для неизвестного/отсутствующего kind. */
+const DEFAULT_ICON = ""; // Text
+/** Возвращает codicon-глиф для `CompletionItemKind` (fallback — дефолтный). */
+export function kindIcon(kind) {
+    if (kind === undefined)
+        return DEFAULT_ICON;
+    return KIND_ICONS[kind] ?? DEFAULT_ICON;
+}

package/dist/completionlist/completionListElement.d.ts

@@ -0,0 +1,102 @@
+import { BoxConstraints, Size } from "@tuidom/core/common/geometryPromitives";
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+/**
+ * Элемент списка автодополнения (payload `data` непрозрачен для TUIDom — там
+ * хранится core-item). `kind` — числовой `CompletionItemKind` для иконки.
+ */
+export interface CompletionListItem {
+    readonly label: string;
+    readonly detail?: string;
+    /** Сигнатура сразу за лейблом (`(a: string): void`), приглушённая. */
+    readonly labelDetail?: string;
+    readonly kind?: number;
+    /**
+     * Текст, по которому пункт фильтруется, если он отличается от лейбла.
+     * Не косметика: tsserver отдаёт после точки dot-accessor-пункты
+     * (`label: "getTime"`, `filterText: ".getTime"`), и фильтрация по лейблу
+     * не нашла бы ни одного при префиксе `.`.
+     */
+    readonly filterText?: string;
+    /** Ключ сортировки источника (у LSP — `sortText`); при равенстве порядок исходный. */
+    readonly sortText?: string;
+    readonly data?: unknown;
+}
+/**
+ * Компактный дропдаун автодополнения в стиле NvChad: рамка (углы `╭╮╰╯` —
+ * единый стиль с остальными оверлеями), выбранный ряд подсвечивается фоном (без
+ * указателей), 1-ячейка паддинга от рамки, колонка codicon-иконки типа.
+ * Собственной строки ввода нет — фильтр внутренний (набор символов сужает
+ * список, не трогая буфер редактора).
+ *
+ * Как в VS Code suggest widget попап **не забирает фокус** (`focusable = false`):
+ * навигацией/принятием/скрытием управляет {@link import("../../../src/vs/workbench/contrib/suggest/browser/completionService.js").CompletionService} через
+ * публичные методы (клавиши приходят командами по `suggestWidgetVisible`), а
+ * фильтрация идёт от префикса под кареткой редактора. Мышью: наведение
+ * подсвечивает ряд, клик принимает пункт.
+ */
+export declare class CompletionListElement extends TUIElement {
+    maxVisibleItems: number;
+    preferredWidth: number;
+    onAccept: ((item: CompletionListItem) => void) | null;
+    /**
+     * Сменился выбранный пункт (клавиатурой, мышью или пере-фильтрацией).
+     * По нему владелец догружает описание для панели — у LSP-источников оно
+     * приходит отдельным запросом на конкретный пункт.
+     */
+    onSelectionChanged: ((item: CompletionListItem | null) => void) | null;
+    private allItems;
+    private filteredItems;
+    private filterValue;
+    private selectedIndexValue;
+    private scrollOffset;
+    /** Кэш {@link contentWidth}; сбрасывается сменой отфильтрованного списка. */
+    private contentWidthCache;
+    constructor();
+    /** Задаёт полный набор элементов; переприменяет текущий фильтр (fresh). */
+    setItems(items: readonly CompletionListItem[]): void;
+    /** Задаёт фильтр «начисто» (пустой результат сворачивает список). */
+    setFilter(value: string): void;
+    /**
+     * Инкрементальное сужение по мере набора: если новый префикс не совпал ни с
+     * чем — **оставляем последний непустой список** (как в VS Code), а не
+     * сворачиваем попап.
+     */
+    refineFilter(value: string): void;
+    /** Видимые (отфильтрованные) элементы. */
+    get items(): readonly CompletionListItem[];
+    get selectedIndex(): number;
+    getSelectedItem(): CompletionListItem | null;
+    private applyFilter;
+    private get visibleItemCount();
+    /**
+     * Ширина содержимого. Считается один раз на смену списка и кэшируется:
+     * layout зовут на каждый кадр, а список от language server'а — это сотни
+     * и тысячи пунктов. По той же причине меряем только первые
+     * {@link WIDTH_SAMPLE_LIMIT} — попап всё равно упирается в `preferredWidth`.
+     */
+    private get contentWidth();
+    private get boxWidth();
+    private get boxHeight();
+    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;
+    private renderRow;
+    selectNext(): void;
+    selectPrevious(): void;
+    selectNextPage(): void;
+    selectPreviousPage(): void;
+    /**
+     * Индекс пункта под локальной Y, или `null`, если это рамка/за пределами
+     * видимых строк. `visibleItemCount` + `scrollOffset` гарантируют, что
+     * возвращённый индекс всегда в пределах `filteredItems`.
+     */
+    private rowAt;
+    private handleMouseMove;
+    private handleClick;
+    private moveSelection;
+    private fireSelectionChanged;
+    private ensureVisible;
+}