@tuidom/elements 0.1.0

package/dist/tree/treeViewElement.js

@@ -0,0 +1,748 @@
+import { DisplayLine } from "@tuidom/core/common/displayLine";
+import { Point } from "@tuidom/core/common/geometryPromitives";
+import { ScrollableElement } from "../scrollbar/scrollableElement.js";
+const INDENT_SIZE = 2;
+// Окно, в течение которого напечатанные символы складываются в одну последовательность
+// быстрого поиска; после паузы буфер сбрасывается (как в VS Code / файловых менеджерах).
+const TYPEAHEAD_TIMEOUT_MS = 800;
+const ICON_EXPANDED = "\uF107"; //  nf-fa-angle_down — chevron, как в nvim-tree/NvChad
+const ICON_COLLAPSED = "\uF105"; //  nf-fa-angle_right
+const SYMLINK_BADGE = "\u21B5"; // enter-like arrow marking a symlink, pinned to the right edge
+export class TreeViewElement extends ScrollableElement {
+    provider;
+    expandedKeys = new Set();
+    childrenCache = new Map();
+    flatNodes = [];
+    selectedIndex = 0;
+    selectionAnchor = 0;
+    hoveredIndex = null;
+    selectedKeys = new Set();
+    cutKeys = new Set();
+    maxRowWidth = 0;
+    /**
+     * Отступ контента строк от левого края элемента. В отличие от внешнего
+     * паддинг-контейнера, входит в саму строку, поэтому фон курсора/выделения
+     * заливает строку от края, а текст начинается со сдвигом.
+     */
+    leftPadding;
+    typeaheadBuffer = "";
+    typeaheadTimer = null;
+    onSelect = null;
+    onActivate = null;
+    onExpandedChanged = null;
+    onContextMenu = null;
+    constructor(provider, options) {
+        super();
+        this.focusable = true;
+        this.leftPadding = options?.leftPadding ?? 0;
+        this.provider = provider;
+        this.provider.onChange = (element) => {
+            void this.refresh(element);
+        };
+    }
+    get contentHeight() {
+        return this.flatNodes.length;
+    }
+    get contentWidth() {
+        return this.maxRowWidth;
+    }
+    async refresh(element) {
+        const selectedKey = this.getSelectedKey();
+        const previousIndex = this.selectedIndex;
+        if (element !== undefined) {
+            const key = this.provider.getKey(element);
+            this.invalidateSubtreeCache(key);
+            await this.reloadExpandedChildren(key);
+        }
+        else {
+            this.childrenCache.clear();
+            await this.loadRootChildren();
+        }
+        this.rebuildFlatList();
+        this.restoreSelection(selectedKey, previousIndex);
+        this.markDirty();
+    }
+    async toggleExpand(element) {
+        const key = this.provider.getKey(element);
+        if (this.expandedKeys.has(key)) {
+            this.expandedKeys.delete(key);
+            this.onExpandedChanged?.(element, false);
+        }
+        else {
+            if (!this.childrenCache.has(key)) {
+                const children = await this.provider.getChildren(element);
+                this.childrenCache.set(key, children);
+            }
+            this.expandedKeys.add(key);
+            this.onExpandedChanged?.(element, true);
+        }
+        this.rebuildFlatList();
+        this.markDirty();
+    }
+    /** Раскрывает узел (идемпотентно, без прокрутки/выделения) и перестраивает список. */
+    async expand(element) {
+        if (this.expandedKeys.has(this.provider.getKey(element)))
+            return;
+        await this.expandElement(element);
+        this.rebuildFlatList();
+        this.markDirty();
+    }
+    /** Раскрывает узел (загружая детей в кеш), если он ещё не раскрыт. No-op для уже раскрытого. */
+    async expandElement(element) {
+        const key = this.provider.getKey(element);
+        if (this.expandedKeys.has(key))
+            return;
+        if (!this.childrenCache.has(key)) {
+            const children = await this.provider.getChildren(element);
+            this.childrenCache.set(key, children);
+        }
+        this.expandedKeys.add(key);
+        this.onExpandedChanged?.(element, true);
+    }
+    /**
+     * Раскрывает цепочку предков и ставит курсор на целевой узел, проматывая к нему.
+     * `chain` — путь от корня к цели включительно: все элементы кроме последнего
+     * трактуются как предки-контейнеры и раскрываются, последний — цель выделения.
+     * Если цель не находится в дереве после раскрытия (например, путь вне корня),
+     * выделение не меняется.
+     */
+    async reveal(chain) {
+        if (chain.length === 0)
+            return;
+        for (let i = 0; i < chain.length - 1; i++) {
+            await this.expandElement(chain[i]);
+        }
+        this.rebuildFlatList();
+        const targetKey = this.provider.getKey(chain[chain.length - 1]);
+        const index = this.flatNodes.findIndex((node) => this.provider.getKey(node.element) === targetKey);
+        if (index >= 0) {
+            this.setSelectedIndex(index);
+        }
+        this.markDirty();
+    }
+    setCutKeys(keys) {
+        this.cutKeys = keys;
+        this.markDirty();
+    }
+    clearCutKeys() {
+        this.cutKeys.clear();
+        this.markDirty();
+    }
+    /** Узел под курсором, либо null если дерево пусто. */
+    getSelectedNode() {
+        if (this.selectedIndex >= 0 && this.selectedIndex < this.flatNodes.length) {
+            return this.flatNodes[this.selectedIndex].element;
+        }
+        return null;
+    }
+    /**
+     * Глобальные экранные координаты выделенной строки — якорь для контекстного меню,
+     * открытого с клавиатуры (Shift+F10). X сдвинут на отступ по глубине узла, чтобы
+     * меню появлялось у имени, а не у левого края панели. Возвращает `null`, если
+     * дерево пусто.
+     */
+    getSelectedRowGlobalPosition() {
+        if (this.selectedIndex < 0 || this.selectedIndex >= this.flatNodes.length)
+            return null;
+        const indentX = this.rowIndentX(this.flatNodes[this.selectedIndex].depth);
+        return new Point(this.globalPosition.x + indentX - this.scrollLeft, this.globalPosition.y + (this.selectedIndex - this.scrollTop));
+    }
+    /**
+     * Все выбранные узлы. Если множественный выбор пуст, возвращает узел под курсором
+     * (в виде массива из одного элемента). Порядок — как в дереве.
+     */
+    getSelectedNodes() {
+        if (this.selectedKeys.size === 0) {
+            const node = this.getSelectedNode();
+            return node ? [node] : [];
+        }
+        const result = [];
+        for (const node of this.flatNodes) {
+            if (this.selectedKeys.has(this.provider.getKey(node.element))) {
+                result.push(node.element);
+            }
+        }
+        return result;
+    }
+    performDefaultAction(event) {
+        if (event.type === "keypress") {
+            this.handleKeypress(event);
+        }
+        else if (event.type === "click") {
+            this.handleClick(event);
+        }
+        else if (event.type === "contextmenu") {
+            this.handleContextMenu(event);
+        }
+        else if (event.type === "dblclick") {
+            this.handleDblClick(event);
+        }
+        else if (event.type === "wheel") {
+            this.handleWheel(event);
+        }
+        else if (event.type === "mousemove") {
+            this.handleMouseMove(event);
+        }
+        else if (event.type === "mouseleave") {
+            this.handleMouseLeave();
+        }
+        else {
+            super.performDefaultAction(event);
+        }
+    }
+    renderViewport(context, viewport) {
+        const { scrollTop, scrollLeft, viewportWidth, viewportHeight } = viewport;
+        const resolved = this.resolvedStyle;
+        const focused = this.isFocused;
+        for (let screenY = 0; screenY < viewportHeight; screenY++) {
+            const nodeIndex = scrollTop + screenY;
+            if (nodeIndex >= this.flatNodes.length) {
+                for (let x = 0; x < viewportWidth; x++) {
+                    context.setCell(x, screenY, { char: " ", fg: resolved.fg, bg: resolved.bg });
+                }
+                continue;
+            }
+            const node = this.flatNodes[nodeIndex];
+            const nodeKey = this.provider.getKey(node.element);
+            const isCursor = nodeIndex === this.selectedIndex;
+            const isSelected = this.selectedKeys.has(nodeKey);
+            const isHovered = nodeIndex === this.hoveredIndex;
+            const isCut = this.cutKeys.has(nodeKey);
+            const { bg: rowBg, fg: rowFg } = this.resolveRowColors(resolved, focused, isCursor, isSelected, isHovered, isCut);
+            const rowText = this.formatRow(node);
+            const rowIcon = node.item.icon;
+            // Данные могут отдавать имена токенов (gitDecoration.*) — резолвим
+            // в контексте дерева: раскраска переживает смену темы без пере-пуша.
+            const rowIconColor = node.item.iconColor !== undefined ? this.resolveColor(node.item.iconColor) : undefined;
+            const labelColor = node.item.labelColor !== undefined ? this.resolveColor(node.item.labelColor) : undefined;
+            // Метка имени начинается сразу после иконки типа (если она есть).
+            const labelStart = this.rowIndentX(node.depth) + 2 + (rowIcon ? 2 : 0);
+            // Цвет-декорация имени уступает выделению/курсору, чтобы выбранная строка
+            // оставалась читаемой (тот же приоритет, что и у cutFg).
+            const labelColorActive = labelColor !== undefined && !(isCursor || isSelected);
+            const dl = new DisplayLine(rowText);
+            let screenX = 0;
+            let col = scrollLeft;
+            while (col < scrollLeft + viewportWidth) {
+                if (col >= dl.displayWidth) {
+                    context.setCell(screenX, screenY, { char: " ", fg: resolved.fg, bg: rowBg });
+                    col++;
+                    screenX++;
+                    continue;
+                }
+                const char = dl.charAtColumn(col);
+                if (char === "") {
+                    col++;
+                    screenX++;
+                    continue;
+                }
+                const slot = dl.graphemeAtColumn(col);
+                /* v8 ignore start -- defensive: graphemeAtColumn is non-null whenever charAtColumn already returned a non-empty char */
+                const w = slot ? slot.displayWidth : 1;
+                /* v8 ignore stop */
+                let fg = rowFg;
+                // Override the name span with the git-status colour (deemphasised by
+                // selection above). Applies only to the label columns, so the type icon
+                // keeps its own colour.
+                if (labelColorActive && col >= labelStart) {
+                    fg = labelColor;
+                }
+                // Color the icon character
+                const iconStart = this.rowIndentX(node.depth) + 2;
+                if (rowIcon && rowIconColor !== undefined && col === iconStart) {
+                    fg = rowIconColor;
+                }
+                // Color the expand icon
+                const expandIconPos = this.rowIndentX(node.depth);
+                if (col === expandIconPos && node.item.collapsible) {
+                    fg = this.styleVar("list.deemphasizedForeground");
+                }
+                if (w === 2 && screenX + 1 >= viewportWidth) {
+                    context.setCell(screenX, screenY, { char: " ", fg, bg: rowBg, width: 1 });
+                    col++;
+                    screenX++;
+                }
+                else {
+                    context.setCell(screenX, screenY, { char, fg, bg: rowBg, width: w });
+                    col += w;
+                    screenX += w;
+                }
+            }
+            // Правый край строки: буква-бейдж статуса (git) прижат к самому краю и
+            // имеет приоритет; стрелка симлинка, если есть, сдвигается влево, чтобы
+            // две метки не перетирали друг друга. Обе рисуются поверх крайних ячеек и
+            // не входят в ширину строки — иконки типов остаются на своих местах.
+            let symlinkX = viewportWidth - 1;
+            if (node.item.badge) {
+                const badgeChars = Array.from(node.item.badge);
+                const badgeFg = labelColor ?? rowFg;
+                const badgeStart = viewportWidth - badgeChars.length;
+                for (let i = 0; i < badgeChars.length; i++) {
+                    const x = badgeStart + i;
+                    if (x >= 0) {
+                        context.setCell(x, screenY, { char: badgeChars[i], fg: badgeFg, bg: rowBg, width: 1 });
+                    }
+                }
+                symlinkX = badgeStart - 1;
+            }
+            if (node.item.symlink && symlinkX >= 0) {
+                context.setCell(symlinkX, screenY, {
+                    char: SYMLINK_BADGE,
+                    fg: this.styleVar("list.deemphasizedForeground"),
+                    bg: rowBg,
+                    width: 1,
+                });
+            }
+        }
+    }
+    resolveRowColors(resolved, focused, isCursor, isSelected, isHovered, isCut) {
+        // Priority: cursor/selection > hover > cut > normal
+        if (isCursor || isSelected) {
+            if (focused) {
+                return {
+                    bg: this.styleVar("list.activeSelectionBackground"),
+                    fg: this.styleVar("list.activeSelectionForeground"),
+                };
+            }
+            return {
+                bg: this.styleVar("list.inactiveSelectionBackground"),
+                fg: this.styleVar("list.inactiveSelectionForeground"),
+            };
+        }
+        if (isHovered) {
+            return { bg: this.styleVar("list.hoverBackground"), fg: resolved.fg };
+        }
+        if (isCut) {
+            return { bg: resolved.bg, fg: this.styleVar("list.deemphasizedForeground") };
+        }
+        return { bg: resolved.bg, fg: resolved.fg };
+    }
+    // ─── Private: data loading ───
+    async loadRootChildren() {
+        const rootChildren = await this.provider.getChildren();
+        this.childrenCache.set("__root__", rootChildren);
+        for (const key of this.expandedKeys) {
+            await this.reloadExpandedChildren(key);
+        }
+    }
+    async reloadExpandedChildren(key) {
+        if (!this.expandedKeys.has(key))
+            return;
+        const node = this.findElementByKey(key);
+        /* v8 ignore start -- unreachable: findElementByKey always resolves an expanded key (see its own v8-ignore note) */
+        if (node === null)
+            return;
+        /* v8 ignore stop */
+        const children = await this.provider.getChildren(node);
+        this.childrenCache.set(key, children);
+        for (const child of children) {
+            const childKey = this.provider.getKey(child);
+            if (this.expandedKeys.has(childKey)) {
+                await this.reloadExpandedChildren(childKey);
+            }
+        }
+    }
+    invalidateSubtreeCache(key) {
+        const children = this.childrenCache.get(key);
+        if (children) {
+            for (const child of children) {
+                const childKey = this.provider.getKey(child);
+                this.invalidateSubtreeCache(childKey);
+            }
+        }
+        this.childrenCache.delete(key);
+    }
+    // ─── Private: flat list ───
+    rebuildFlatList() {
+        this.flatNodes = [];
+        this.maxRowWidth = 0;
+        const rootChildren = this.childrenCache.get("__root__");
+        if (!rootChildren)
+            return;
+        this.appendChildren(rootChildren, 0, null);
+    }
+    appendChildren(children, depth, parentKey) {
+        for (const element of children) {
+            const key = this.provider.getKey(element);
+            const item = this.provider.getTreeItem(element);
+            this.flatNodes.push({ element, depth, item, parentKey });
+            const rowWidth = this.calculateRowWidth(depth, item);
+            if (rowWidth > this.maxRowWidth) {
+                this.maxRowWidth = rowWidth;
+            }
+            if (this.expandedKeys.has(key)) {
+                const cachedChildren = this.childrenCache.get(key);
+                /* v8 ignore start -- defensive: an expanded key always has its children cached (cache and expandedKeys stay in sync) */
+                if (cachedChildren) {
+                    this.appendChildren(cachedChildren, depth + 1, key);
+                }
+                /* v8 ignore stop */
+            }
+        }
+    }
+    /** Колонка (в координатах контента), с которой начинается строка узла данной глубины. */
+    rowIndentX(depth) {
+        return this.leftPadding + depth * INDENT_SIZE;
+    }
+    calculateRowWidth(depth, item) {
+        // indent + expandIcon + space + icon + space + label
+        return this.rowIndentX(depth) + 2 + (item.icon ? 2 : 0) + new DisplayLine(item.label).displayWidth;
+    }
+    formatRow(node) {
+        const indent = " ".repeat(this.rowIndentX(node.depth));
+        const expandIcon = node.item.collapsible
+            ? this.expandedKeys.has(this.provider.getKey(node.element))
+                ? ICON_EXPANDED
+                : ICON_COLLAPSED
+            : " ";
+        const icon = node.item.icon ? node.item.icon + " " : "";
+        return `${indent}${expandIcon} ${icon}${node.item.label}`;
+    }
+    // ─── Private: selection ───
+    getSelectedKey() {
+        if (this.selectedIndex >= 0 && this.selectedIndex < this.flatNodes.length) {
+            return this.provider.getKey(this.flatNodes[this.selectedIndex].element);
+        }
+        return null;
+    }
+    restoreSelection(key, previousIndex) {
+        if (key !== null) {
+            const idx = this.flatNodes.findIndex((n) => this.provider.getKey(n.element) === key);
+            if (idx >= 0) {
+                this.selectedIndex = idx;
+                this.selectionAnchor = idx;
+                return;
+            }
+        }
+        // The previously selected node is gone (e.g. it was deleted). Keep the cursor
+        // on the nearest remaining row instead of jumping to the top of the tree: the
+        // next sibling shifts into the same index, or we clamp to the last row when the
+        // deleted node was last.
+        if (this.flatNodes.length === 0) {
+            this.selectedIndex = 0;
+            this.selectionAnchor = 0;
+            return;
+        }
+        this.selectedIndex = Math.min(Math.max(previousIndex, 0), this.flatNodes.length - 1);
+        this.selectionAnchor = this.selectedIndex;
+    }
+    focusPageDown() {
+        const pageSize = Math.max(1, this.layoutSize.height - 1);
+        this.setSelectedIndex(this.selectedIndex + pageSize);
+    }
+    focusPageUp() {
+        const pageSize = Math.max(1, this.layoutSize.height - 1);
+        this.setSelectedIndex(this.selectedIndex - pageSize);
+    }
+    focusFirst() {
+        this.setSelectedIndex(0);
+    }
+    focusLast() {
+        this.setSelectedIndex(this.flatNodes.length - 1);
+    }
+    setSelectedIndex(index) {
+        if (index < 0)
+            index = 0;
+        if (index >= this.flatNodes.length)
+            index = this.flatNodes.length - 1;
+        if (index < 0)
+            return;
+        this.selectedIndex = index;
+        this.selectionAnchor = index;
+        this.selectedKeys.clear();
+        this.applyCursor(index);
+    }
+    /** Двигает курсор и расширяет множественный выбор диапазоном от якоря (Shift+стрелки). */
+    extendSelectionTo(index) {
+        if (index < 0)
+            index = 0;
+        if (index >= this.flatNodes.length)
+            index = this.flatNodes.length - 1;
+        if (index < 0)
+            return;
+        this.selectedIndex = index;
+        this.selectRange(this.selectionAnchor, index);
+        this.applyCursor(index);
+    }
+    selectRange(anchor, cursor) {
+        const lo = Math.min(anchor, cursor);
+        const hi = Math.max(anchor, cursor);
+        this.selectedKeys.clear();
+        for (let i = lo; i <= hi; i++) {
+            this.selectedKeys.add(this.provider.getKey(this.flatNodes[i].element));
+        }
+    }
+    /** Переключает выбор одной строки (Ctrl/Cmd+клик), не сбрасывая остальное. */
+    toggleSelectionAt(index) {
+        /* v8 ignore start -- defensive: the mouse handler bounds-checks the row before calling */
+        if (index < 0 || index >= this.flatNodes.length)
+            return;
+        /* v8 ignore stop */
+        // Первый Ctrl+клик: включаем в набор текущий курсор, чтобы он не потерялся.
+        if (this.selectedKeys.size === 0) {
+            this.selectedKeys.add(this.provider.getKey(this.flatNodes[this.selectedIndex].element));
+        }
+        const key = this.provider.getKey(this.flatNodes[index].element);
+        if (this.selectedKeys.has(key)) {
+            this.selectedKeys.delete(key);
+        }
+        else {
+            this.selectedKeys.add(key);
+        }
+        this.selectedIndex = index;
+        this.selectionAnchor = index;
+        this.applyCursor(index);
+    }
+    applyCursor(index) {
+        this.ensureVisible(index);
+        this.onSelect?.(this.flatNodes[index].element);
+        this.markDirty();
+    }
+    ensureVisible(index) {
+        const viewportHeight = this.layoutSize.height;
+        if (index < this.scrollTop) {
+            this.scrollTo(this.scrollLeft, index);
+        }
+        else if (index >= this.scrollTop + viewportHeight) {
+            this.scrollTo(this.scrollLeft, index - viewportHeight + 1);
+        }
+    }
+    // ─── Private: key helpers ───
+    findElementByKey(key) {
+        for (const node of this.flatNodes) {
+            if (this.provider.getKey(node.element) === key) {
+                return node.element;
+            }
+        }
+        /* v8 ignore start -- unreachable: findElementByKey is only called with keys of currently-flattened (visible) nodes, which the loop above always finds */
+        // Search in cache values too
+        for (const children of this.childrenCache.values()) {
+            for (const child of children) {
+                if (this.provider.getKey(child) === key) {
+                    return child;
+                }
+            }
+        }
+        return null;
+        /* v8 ignore stop */
+    }
+    // ─── Private: input handlers ───
+    handleKeypress(event) {
+        switch (event.key) {
+            case "ArrowUp":
+                if (event.shiftKey) {
+                    this.extendSelectionTo(this.selectedIndex - 1);
+                }
+                else {
+                    this.setSelectedIndex(this.selectedIndex - 1);
+                }
+                break;
+            case "ArrowDown":
+                if (event.shiftKey) {
+                    this.extendSelectionTo(this.selectedIndex + 1);
+                }
+                else {
+                    this.setSelectedIndex(this.selectedIndex + 1);
+                }
+                break;
+            case "ArrowRight":
+                void this.handleExpandOrMoveToChild();
+                break;
+            case "ArrowLeft":
+                void this.handleCollapseOrMoveToParent();
+                break;
+            case "Enter":
+                this.activateSelected();
+                break;
+            case " ":
+                void this.toggleSelected();
+                break;
+            default:
+                this.handleTypeahead(event);
+                return;
+        }
+    }
+    // ─── Private: type-ahead поиск ───
+    /**
+     * Быстрый поиск по набору: печатаешь символы — курсор перепрыгивает к первому узлу,
+     * чья метка начинается с набранной последовательности. Повтор одного и того же
+     * символа циклически перебирает совпадения; набор из разных символов уточняет
+     * префикс, начиная с текущей строки. Буфер копится, пока не выйдет тайм-аут.
+     */
+    handleTypeahead(event) {
+        if (event.ctrlKey || event.altKey || event.metaKey)
+            return;
+        const ch = event.key;
+        // Только одиночные печатные символы: имена клавиш ("Enter", "F1"), управляющие
+        // символы и пробел (уже занят разворачиванием) в поиск не идут.
+        if (ch.length !== 1 || ch === " " || ch.charCodeAt(0) < 0x20)
+            return;
+        this.typeaheadBuffer += ch;
+        this.restartTypeaheadTimer();
+        this.jumpToTypeaheadMatch();
+    }
+    restartTypeaheadTimer() {
+        if (this.typeaheadTimer !== null) {
+            clearTimeout(this.typeaheadTimer);
+        }
+        this.typeaheadTimer = setTimeout(() => {
+            this.typeaheadTimer = null;
+            this.typeaheadBuffer = "";
+        }, TYPEAHEAD_TIMEOUT_MS);
+        // Незавершённый таймер поиска не должен удерживать процесс от выхода.
+        this.typeaheadTimer.unref();
+    }
+    jumpToTypeaheadMatch() {
+        const count = this.flatNodes.length;
+        if (count === 0)
+            return;
+        const buffer = this.typeaheadBuffer.toLowerCase();
+        // Повтор одного символа ("aa", "aaa") трактуем как перебор совпадений по одной
+        // букве, а не как буквальный префикс — так работает быстрый поиск в проводниках.
+        const allSameChar = Array.from(buffer).every((c) => c === buffer[0]);
+        const prefix = allSameChar ? buffer[0] : buffer;
+        // Перебор (следующая строка) — только когда пользователь реально жмёт ту же
+        // клавишу повторно (буфер ≥ 2 и все символы одинаковы). Первое нажатие и
+        // уточнение префикса ищут с текущей строки включительно, чтобы найти первое
+        // совпадение на текущей позиции или после неё.
+        const cycling = buffer.length >= 2 && allSameChar;
+        const start = cycling ? this.selectedIndex + 1 : this.selectedIndex;
+        for (let i = 0; i < count; i++) {
+            const idx = (start + i) % count;
+            const label = this.flatNodes[idx].item.label.toLowerCase();
+            if (label.startsWith(prefix)) {
+                this.setSelectedIndex(idx);
+                return;
+            }
+        }
+    }
+    async handleExpandOrMoveToChild() {
+        const node = this.flatNodes[this.selectedIndex];
+        if (node.item.collapsible) {
+            const key = this.provider.getKey(node.element);
+            if (!this.expandedKeys.has(key)) {
+                await this.toggleExpand(node.element);
+            }
+            else {
+                // Already expanded — move to first child
+                if (this.selectedIndex + 1 < this.flatNodes.length) {
+                    const nextNode = this.flatNodes[this.selectedIndex + 1];
+                    if (nextNode.depth > node.depth) {
+                        this.setSelectedIndex(this.selectedIndex + 1);
+                    }
+                }
+            }
+        }
+    }
+    async handleCollapseOrMoveToParent() {
+        const node = this.flatNodes[this.selectedIndex];
+        const key = this.provider.getKey(node.element);
+        if (node.item.collapsible && this.expandedKeys.has(key)) {
+            await this.toggleExpand(node.element);
+        }
+        else if (node.parentKey !== null) {
+            const parentIdx = this.flatNodes.findIndex((n) => this.provider.getKey(n.element) === node.parentKey);
+            /* v8 ignore start -- defensive: a visible child's parent is always present in the flat list */
+            if (parentIdx >= 0) {
+                this.setSelectedIndex(parentIdx);
+            }
+            /* v8 ignore stop */
+        }
+    }
+    activateSelected() {
+        const node = this.flatNodes[this.selectedIndex];
+        this.onActivate?.(node.element);
+    }
+    async toggleSelected() {
+        const node = this.flatNodes[this.selectedIndex];
+        if (!node.item.collapsible)
+            return;
+        await this.toggleExpand(node.element);
+    }
+    /**
+     * Единый вход контекстного меню: от мыши — узел под кликом (мультивыбор по
+     * выбранной строке не сбрасывается), от клавиатуры — узел курсора с якорем
+     * на его глобальной позиции. Виджет только сигналит {@link onContextMenu}.
+     */
+    handleContextMenu(event) {
+        if (event.trigger === "mouse") {
+            const index = this.scrollTop + event.localY;
+            if (index < 0 || index >= this.flatNodes.length)
+                return;
+            // Не сбрасываем множественный выбор, если кликнули по уже выбранной строке.
+            const key = this.provider.getKey(this.flatNodes[index].element);
+            if (!this.selectedKeys.has(key)) {
+                this.setSelectedIndex(index);
+            }
+            else {
+                this.selectedIndex = index;
+                this.applyCursor(index);
+            }
+            this.onContextMenu?.(this.flatNodes[index].element, event.screenX, event.screenY);
+            return;
+        }
+        const anchor = this.getSelectedRowGlobalPosition();
+        if (anchor === null || this.selectedIndex < 0 || this.selectedIndex >= this.flatNodes.length)
+            return;
+        this.onContextMenu?.(this.flatNodes[this.selectedIndex].element, anchor.x, anchor.y);
+    }
+    handleClick(event) {
+        const index = this.scrollTop + event.localY;
+        if (index < 0 || index >= this.flatNodes.length)
+            return;
+        if (event.button !== "left")
+            return; // правый клик несёт событие contextmenu
+        if (event.ctrlKey) {
+            this.toggleSelectionAt(index);
+            return;
+        }
+        if (event.shiftKey) {
+            this.selectedIndex = index;
+            this.selectRange(this.selectionAnchor, index);
+            this.applyCursor(index);
+            return;
+        }
+        this.setSelectedIndex(index);
+        // Check if clicked on expand icon area
+        const node = this.flatNodes[index];
+        const expandIconX = this.rowIndentX(node.depth);
+        const clickX = this.scrollLeft + event.localX;
+        if (node.item.collapsible && clickX >= expandIconX && clickX <= expandIconX + 1) {
+            void this.toggleExpand(node.element);
+        }
+    }
+    handleDblClick(event) {
+        const index = this.scrollTop + event.localY;
+        if (index < 0 || index >= this.flatNodes.length)
+            return;
+        const node = this.flatNodes[index];
+        if (node.item.collapsible) {
+            void this.toggleExpand(node.element);
+        }
+        else {
+            this.onActivate?.(node.element);
+        }
+    }
+    handleMouseMove(event) {
+        const index = this.scrollTop + event.localY;
+        const newHovered = index >= 0 && index < this.flatNodes.length ? index : null;
+        if (newHovered !== this.hoveredIndex) {
+            this.hoveredIndex = newHovered;
+            this.markDirty();
+        }
+    }
+    handleMouseLeave() {
+        if (this.hoveredIndex !== null) {
+            this.hoveredIndex = null;
+            this.markDirty();
+        }
+    }
+    handleWheel(event) {
+        if (event.wheelDirection === "up") {
+            this.scrollBy(0, -3);
+        }
+        else if (event.wheelDirection === "down") {
+            this.scrollBy(0, 3);
+        }
+    }
+}