mepcli 0.5.5 → 0.6.0

package/dist/prompts/text.js

@@ -15,14 +15,18 @@ class TextPrompt extends base_1.Prompt {
         this.cursor = 0;
         this.hasTyped = false;
         this.segments = [];
+        this.lastLinesUp = 0;
         this.value = options.initial || '';
         // Initialize segments from value
         this.segments = (0, utils_1.safeSplit)(this.value);
         this.cursor = this.segments.length;
     }
     render(firstRender) {
+        if (!firstRender && this.lastLinesUp > 0) {
+            this.print(`\x1b[${this.lastLinesUp}B`);
+        }
+        this.lastLinesUp = 0;
         // Calculate available width
-        const cols = process.stdout.columns || 80;
         // 1. Prepare Prompt Label
         const icon = this.errorMsg ? `${theme_1.theme.error}${symbols_1.symbols.cross}` : `${theme_1.theme.success}?`;
         const hint = this.options.multiline ? ` ${theme_1.theme.muted}(Press Ctrl+D to submit)${ansi_1.ANSI.RESET}` : '';
@@ -43,31 +47,16 @@ class TextPrompt extends base_1.Prompt {
             cursorRelativeCol = 0;
         }
         else {
-            const rawValue = this.options.isPassword ? '*'.repeat(this.segments.length) : this.value;
+            const maskChar = this.options.mask ?? (this.options.isPassword ? '*' : undefined);
             // Note: password masking replaces each grapheme with '*'
             // Split by lines (for multiline support)
-            const lines = rawValue.split('\n');
             // Determine which line the cursor is on
             // We need to map 'cursor' (segments index) to line/col.
             // This is tricky because segments might contain '\n'.
             // safeSplit treats '\n' as a segment.
             let cursorLineIndex = 0;
-            const cursorSegmentIndexOnLine = 0;
-            const currentSegmentIndex = 0;
-            for (let i = 0; i < lines.length; i++) {
-                // How many segments in this line?
-                // We can't just use lines[i].length because that's chars.
-                // We need to split the line again or iterate segments.
-                // Iterating segments is safer.
-                // Let's assume we iterate global segments until we hit a newline segment
-                const lineSegmentsCount = 0;
-                // Since rawValue.split('\n') consumes the newlines, we need to account for them.
-                // Alternative: iterate this.segments
-                // Find where the cursor falls.
-            }
             // Let's iterate segments to find cursor position (row, col)
             cursorLineIndex = 0;
-            const colIndex = 0; // Visual column or char index?
             // If we want visual cursor position, we need visual width of segments.
             let visualColIndex = 0;
             for (let i = 0; i < this.cursor; i++) {
@@ -77,11 +66,11 @@ class TextPrompt extends base_1.Prompt {
                     visualColIndex = 0;
                 }
                 else {
-                    if (this.options.isPassword) {
-                        visualColIndex += 1;
+                    if (maskChar !== undefined) {
+                        visualColIndex += maskChar.length;
                     }
                     else {
-                        visualColIndex += this.options.isPassword ? 1 : this.getSegmentWidth(seg);
+                        visualColIndex += this.getSegmentWidth(seg);
                     }
                 }
             }
@@ -101,24 +90,16 @@ class TextPrompt extends base_1.Prompt {
                 }
             }
             processedLines.push(currentLineSegments); // Last line
-            processedLines.forEach((lineSegs, idx) => {
-                const isCursorLine = idx === cursorLineIndex;
-                const linePrefixLen = (idx === 0) ? prefixVisualLen : 0;
-                const maxContentLen = Math.max(10, cols - linePrefixLen - 1);
+            processedLines.forEach((lineSegs) => {
                 // Reconstruct line string for display calculation
                 // If password, join with *?
                 let visibleLine = '';
-                if (this.options.isPassword) {
-                    visibleLine = '*'.repeat(lineSegs.length);
+                if (maskChar !== undefined) {
+                    visibleLine = maskChar.repeat(lineSegs.length);
                 }
                 else {
                     visibleLine = lineSegs.join('');
                 }
-                // If this is cursor line, we need to handle horizontal scroll based on cursorRelativeCol.
-                // But cursorRelativeCol is global? No, we reset it on newline.
-                // So cursorRelativeCol above was correct for the current line.
-                if (isCursorLine) {
-                }
                 displayValueLines.push(theme_1.theme.main + visibleLine + ansi_1.ANSI.RESET);
             });
         }
@@ -145,6 +126,7 @@ class TextPrompt extends base_1.Prompt {
         if (linesUp > 0) {
             this.print(`\x1b[${linesUp}A`);
         }
+        this.lastLinesUp = linesUp;
         let targetCol = 0;
         if (cursorRelativeRow === 0) {
             targetCol = prefixVisualLen + cursorRelativeCol;

package/dist/prompts/toggle.d.ts

@@ -2,7 +2,7 @@ import { Prompt } from '../base';
 import { ToggleOptions, MouseEvent } from '../types';
 export declare class TogglePrompt extends Prompt<boolean, ToggleOptions> {
     constructor(options: ToggleOptions);
-    protected render(firstRender: boolean): void;
+    protected render(_firstRender: boolean): void;
     protected handleInput(char: string): void;
     protected handleMouse(event: MouseEvent): void;
 }

package/dist/prompts/toggle.js

@@ -10,7 +10,7 @@ class TogglePrompt extends base_1.Prompt {
         super(options);
         this.value = options.initial ?? false;
     }
-    render(firstRender) {
+    render(_firstRender) {
         const activeText = this.options.activeText || 'ON';
         const inactiveText = this.options.inactiveText || 'OFF';
         let toggleDisplay = '';

package/dist/prompts/transfer.d.ts

@@ -0,0 +1,18 @@
+import { Prompt } from '../base';
+import { TransferOptions, MouseEvent } from '../types';
+export declare class TransferPrompt<V> extends Prompt<[V[], V[]], TransferOptions<V>> {
+    private leftList;
+    private rightList;
+    private cursorLeft;
+    private cursorRight;
+    private scrollTopLeft;
+    private scrollTopRight;
+    private activeSide;
+    private readonly pageSize;
+    constructor(options: TransferOptions<V>);
+    private normalize;
+    protected truncate(str: string, width: number): string;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string): void;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/transfer.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+const utils_1 = require("../utils");
+class TransferPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.leftList = [];
+        this.rightList = [];
+        this.cursorLeft = 0;
+        this.cursorRight = 0;
+        this.scrollTopLeft = 0;
+        this.scrollTopRight = 0;
+        this.activeSide = 'left';
+        this.pageSize = 10;
+        this.leftList = this.normalize(options.source);
+        this.rightList = this.normalize(options.target || []);
+    }
+    normalize(items) {
+        return items.map(item => {
+            if (typeof item === 'string') {
+                return { title: item, value: item };
+            }
+            return item;
+        });
+    }
+    truncate(str, width) {
+        if ((0, utils_1.stringWidth)(str) <= width)
+            return str;
+        let res = str;
+        while ((0, utils_1.stringWidth)(res + '...') > width && res.length > 0) {
+            res = res.slice(0, -1);
+        }
+        return res + '...';
+    }
+    render(_firstRender) {
+        const termWidth = process.stdout.columns || 80;
+        const colWidth = Math.floor((termWidth - 6) / 2);
+        // Adjust Scroll Top
+        if (this.activeSide === 'left') {
+            if (this.cursorLeft < this.scrollTopLeft)
+                this.scrollTopLeft = this.cursorLeft;
+            if (this.cursorLeft >= this.scrollTopLeft + this.pageSize)
+                this.scrollTopLeft = this.cursorLeft - this.pageSize + 1;
+        }
+        else {
+            if (this.cursorRight < this.scrollTopRight)
+                this.scrollTopRight = this.cursorRight;
+            if (this.cursorRight >= this.scrollTopRight + this.pageSize)
+                this.scrollTopRight = this.cursorRight - this.pageSize + 1;
+        }
+        let output = `${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        // Headers
+        const leftTitle = this.activeSide === 'left' ? `${theme_1.theme.main}Source${ansi_1.ANSI.RESET}` : 'Source';
+        const rightTitle = this.activeSide === 'right' ? `${theme_1.theme.main}Target${ansi_1.ANSI.RESET}` : 'Target';
+        output += `  ${leftTitle}`.padEnd(colWidth + 2) + '   ' + `  ${rightTitle}\n`;
+        output += `  ${ansi_1.ANSI.DIM}${symbols_1.symbols.line.repeat(colWidth)}${ansi_1.ANSI.RESET}   ${ansi_1.ANSI.DIM}${symbols_1.symbols.line.repeat(colWidth)}${ansi_1.ANSI.RESET}\n`;
+        for (let i = 0; i < this.pageSize; i++) {
+            const idxLeft = this.scrollTopLeft + i;
+            const idxRight = this.scrollTopRight + i;
+            const itemLeft = this.leftList[idxLeft];
+            const itemRight = this.rightList[idxRight];
+            // Left Column
+            let leftStr = '';
+            if (itemLeft) {
+                const isSelected = this.activeSide === 'left' && idxLeft === this.cursorLeft;
+                const title = this.truncate(itemLeft.title, colWidth - 2);
+                if (isSelected) {
+                    leftStr = `${theme_1.theme.main}${symbols_1.symbols.pointer} ${title}${ansi_1.ANSI.RESET}`;
+                }
+                else {
+                    leftStr = `  ${title}`;
+                }
+            }
+            else {
+                leftStr = ''; // Empty
+            }
+            // Right Column
+            let rightStr = '';
+            if (itemRight) {
+                const isSelected = this.activeSide === 'right' && idxRight === this.cursorRight;
+                const title = this.truncate(itemRight.title, colWidth - 2);
+                if (isSelected) {
+                    rightStr = `${theme_1.theme.main}${symbols_1.symbols.pointer} ${title}${ansi_1.ANSI.RESET}`;
+                }
+                else {
+                    rightStr = `  ${title}`;
+                }
+            }
+            const leftVisualWidth = itemLeft ? ((0, utils_1.stringWidth)(this.truncate(itemLeft.title, colWidth - 2)) + 2) : 0;
+            // Pad visually
+            const padding = ' '.repeat(Math.max(0, colWidth - leftVisualWidth));
+            output += leftStr + padding + ' | ' + rightStr + '\n';
+        }
+        output += `\n${ansi_1.ANSI.DIM}(Tab: Switch | a: Move All Right | r: Reset/All Left)${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            const leftValues = this.leftList.map(i => i.value);
+            const rightValues = this.rightList.map(i => i.value);
+            this.submit([leftValues, rightValues]);
+            return;
+        }
+        if (char === '\t' || this.isLeft(char) || this.isRight(char)) {
+            // Toggle side
+            this.activeSide = this.activeSide === 'left' ? 'right' : 'left';
+            this.render(false);
+            return;
+        }
+        // --- Batch Transfer Shortcuts ---
+        // Move All to Right ('a' or '>')
+        if (char === 'a' || char === '>') {
+            if (this.leftList.length > 0) {
+                this.rightList.push(...this.leftList);
+                this.leftList = [];
+                this.cursorLeft = 0;
+                this.activeSide = 'right';
+                this.render(false);
+            }
+            return;
+        }
+        // Move All to Left ('r' or '<')
+        if (char === 'r' || char === '<') {
+            if (this.rightList.length > 0) {
+                this.leftList.push(...this.rightList);
+                this.rightList = [];
+                this.cursorRight = 0;
+                this.activeSide = 'left';
+                this.render(false);
+            }
+            return;
+        }
+        if (this.isUp(char)) {
+            if (this.activeSide === 'left') {
+                this.cursorLeft = Math.max(0, this.cursorLeft - 1);
+            }
+            else {
+                this.cursorRight = Math.max(0, this.cursorRight - 1);
+            }
+            this.render(false);
+            return;
+        }
+        if (this.isDown(char)) {
+            if (this.activeSide === 'left') {
+                this.cursorLeft = Math.min(this.leftList.length - 1, this.cursorLeft + 1);
+            }
+            else {
+                this.cursorRight = Math.min(this.rightList.length - 1, this.cursorRight + 1);
+            }
+            this.render(false);
+            return;
+        }
+        if (char === ' ') {
+            // Move item
+            if (this.activeSide === 'left') {
+                if (this.leftList.length > 0) {
+                    const [item] = this.leftList.splice(this.cursorLeft, 1);
+                    this.rightList.push(item);
+                    if (this.cursorLeft >= this.leftList.length) {
+                        this.cursorLeft = Math.max(0, this.leftList.length - 1);
+                    }
+                }
+            }
+            else {
+                if (this.rightList.length > 0) {
+                    const [item] = this.rightList.splice(this.cursorRight, 1);
+                    this.leftList.push(item);
+                    if (this.cursorRight >= this.rightList.length) {
+                        this.cursorRight = Math.max(0, this.rightList.length - 1);
+                    }
+                }
+            }
+            this.render(false);
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                if (this.activeSide === 'left') {
+                    this.cursorLeft = Math.max(0, this.cursorLeft - 1);
+                }
+                else {
+                    this.cursorRight = Math.max(0, this.cursorRight - 1);
+                }
+            }
+            else {
+                if (this.activeSide === 'left') {
+                    this.cursorLeft = Math.min(this.leftList.length - 1, this.cursorLeft + 1);
+                }
+                else {
+                    this.cursorRight = Math.min(this.rightList.length - 1, this.cursorRight + 1);
+                }
+            }
+            this.render(false);
+        }
+    }
+}
+exports.TransferPrompt = TransferPrompt;

package/dist/prompts/tree-select.d.ts

@@ -0,0 +1,32 @@
+import { Prompt } from '../base';
+import { TreeSelectOptions, MouseEvent } from '../types';
+/**
+ * FIXED-ISH: This prompt may hang on Windows TTY after multiple prompt cycles.
+ * Current workaround: User must press 'Enter' to flush the stdin buffer.
+ * Potential root cause: Synchronous recursion during initialization blocking setRawMode.
+ */
+export declare class TreeSelectPrompt<V> extends Prompt<V[], TreeSelectOptions<V>> {
+    private cursor;
+    private expandedNodes;
+    private flatList;
+    private scrollTop;
+    private readonly pageSize;
+    private parentMap;
+    private static hasWarnedWindows;
+    private readonly ICON_CLOSED;
+    private readonly ICON_OPEN;
+    constructor(options: TreeSelectOptions<V>);
+    private buildParentMap;
+    private initializeExpanded;
+    private initializeSelection;
+    private recalculateAllParents;
+    private updateNodeStateFromChildren;
+    private setNodeState;
+    private recalculateFlatList;
+    private traverse;
+    private toggleRecursive;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string, _key: Buffer): void;
+    private collectSelected;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/tree-select.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeSelectPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+/**
+ * FIXED-ISH: This prompt may hang on Windows TTY after multiple prompt cycles.
+ * Current workaround: User must press 'Enter' to flush the stdin buffer.
+ * Potential root cause: Synchronous recursion during initialization blocking setRawMode.
+ */
+class TreeSelectPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.cursor = 0;
+        this.expandedNodes = new Set();
+        this.flatList = [];
+        this.scrollTop = 0;
+        this.pageSize = 15;
+        this.parentMap = new Map();
+        this.ICON_CLOSED = symbols_1.symbols.pointer === '>' ? '+' : '▸';
+        this.ICON_OPEN = symbols_1.symbols.pointer === '>' ? '-' : '▾';
+        this.buildParentMap(this.options.data, null);
+        this.initializeExpanded(this.options.data);
+        if (this.options.initial) {
+            const initialSet = new Set(this.options.initial);
+            this.initializeSelection(this.options.data, initialSet);
+            this.recalculateAllParents(this.options.data);
+        }
+        if (process.platform === 'win32' && !TreeSelectPrompt.hasWarnedWindows) {
+            console.warn(`${ansi_1.ANSI.FG_YELLOW}Warning:${ansi_1.ANSI.RESET} TreeSelectPrompt may hang on Windows TTY after multiple prompt cycles. Please press 'Enter' if the prompt becomes unresponsive.${ansi_1.ANSI.RESET}`);
+            TreeSelectPrompt.hasWarnedWindows = true;
+        }
+        this.recalculateFlatList();
+    }
+    buildParentMap(nodes, parent) {
+        for (const node of nodes) {
+            if (parent)
+                this.parentMap.set(node, parent);
+            if (node.children) {
+                this.buildParentMap(node.children, node);
+            }
+        }
+    }
+    initializeExpanded(nodes) {
+        for (const node of nodes) {
+            if (node.expanded) {
+                this.expandedNodes.add(node);
+            }
+            if (node.children) {
+                this.initializeExpanded(node.children);
+            }
+        }
+    }
+    initializeSelection(nodes, initialValues) {
+        for (const node of nodes) {
+            if (initialValues.has(node.value)) {
+                this.setNodeState(node, true, false);
+            }
+            if (node.children) {
+                this.initializeSelection(node.children, initialValues);
+            }
+        }
+    }
+    recalculateAllParents(nodes) {
+        for (const node of nodes) {
+            if (node.children) {
+                this.recalculateAllParents(node.children);
+                this.updateNodeStateFromChildren(node);
+            }
+        }
+    }
+    updateNodeStateFromChildren(node) {
+        if (!node.children || node.children.length === 0)
+            return;
+        const allChecked = node.children.every(c => c.selected === true);
+        const allUnchecked = node.children.every(c => !c.selected);
+        if (allChecked) {
+            node.selected = true;
+        }
+        else if (allUnchecked) {
+            node.selected = false;
+        }
+        else {
+            node.selected = 'indeterminate';
+        }
+    }
+    setNodeState(node, state, updateParents = true) {
+        node.selected = state;
+        if (node.children) {
+            node.children.forEach(c => this.setNodeState(c, state, false));
+        }
+        if (updateParents) {
+            let curr = node;
+            while (this.parentMap.has(curr)) {
+                const parent = this.parentMap.get(curr);
+                this.updateNodeStateFromChildren(parent);
+                curr = parent;
+            }
+        }
+    }
+    recalculateFlatList() {
+        this.flatList = [];
+        this.traverse(this.options.data, 0, null);
+        if (this.cursor >= this.flatList.length) {
+            this.cursor = Math.max(0, this.flatList.length - 1);
+        }
+    }
+    traverse(nodes, depth, parent) {
+        for (const node of nodes) {
+            this.flatList.push({ node, depth, parent });
+            if (node.children && node.children.length > 0 && this.expandedNodes.has(node)) {
+                this.traverse(node.children, depth + 1, node);
+            }
+        }
+    }
+    toggleRecursive(node, expand) {
+        if (expand)
+            this.expandedNodes.add(node);
+        else
+            this.expandedNodes.delete(node);
+        if (node.children) {
+            node.children.forEach(child => this.toggleRecursive(child, expand));
+        }
+    }
+    render(_firstRender) {
+        let output = `${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        if (this.flatList.length === 0) {
+            output += `  ${theme_1.theme.muted}No data${ansi_1.ANSI.RESET}`;
+            this.renderFrame(output);
+            return;
+        }
+        if (this.cursor < this.scrollTop) {
+            this.scrollTop = this.cursor;
+        }
+        else if (this.cursor >= this.scrollTop + this.pageSize) {
+            this.scrollTop = this.cursor - this.pageSize + 1;
+        }
+        const visible = this.flatList.slice(this.scrollTop, this.scrollTop + this.pageSize);
+        visible.forEach((item, index) => {
+            const actualIndex = this.scrollTop + index;
+            const isSelected = actualIndex === this.cursor;
+            const indentSize = this.options.indent || 2;
+            const indentation = ' '.repeat(item.depth * indentSize);
+            const linePrefix = isSelected ? `${theme_1.theme.main}${symbols_1.symbols.pointer} ` : '  ';
+            let folderIcon = '  ';
+            const hasChildren = item.node.children && item.node.children.length > 0;
+            if (hasChildren) {
+                folderIcon = this.expandedNodes.has(item.node) ? `${this.ICON_OPEN} ` : `${this.ICON_CLOSED} `;
+            }
+            // Checkbox
+            let checkIcon = `[ ]`;
+            if (item.node.selected === true) {
+                checkIcon = `${theme_1.theme.success}[x]${ansi_1.ANSI.RESET}`;
+            }
+            else if (item.node.selected === 'indeterminate') {
+                checkIcon = `${ansi_1.ANSI.FG_YELLOW}[-]${ansi_1.ANSI.RESET}`;
+            }
+            else {
+                checkIcon = `${theme_1.theme.muted}[ ]${ansi_1.ANSI.RESET}`;
+            }
+            let title = item.node.title;
+            if (item.node.disabled) {
+                title = `${theme_1.theme.muted}${title} (disabled)${ansi_1.ANSI.RESET}`;
+            }
+            let line = `${indentation}${folderIcon}${checkIcon} ${title}`;
+            if (isSelected) {
+                line = `${theme_1.theme.main}${line}${ansi_1.ANSI.RESET}`;
+            }
+            output += linePrefix + line;
+            if (index < visible.length - 1)
+                output += '\n';
+        });
+        output += `\n${theme_1.theme.muted}(e: Expand All, c: Collapse All, Space: Toggle)${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+    handleInput(char, _key) {
+        if (this.flatList.length === 0)
+            return;
+        // 1. Priority: Navigation keys (ANSI sequences)
+        if (this.isUp(char)) {
+            this.cursor = (this.cursor - 1 + this.flatList.length) % this.flatList.length;
+            this.render(false);
+            return;
+        }
+        if (this.isDown(char)) {
+            this.cursor = (this.cursor + 1) % this.flatList.length;
+            this.render(false);
+            return;
+        }
+        const currentItem = this.flatList[this.cursor];
+        if (!currentItem)
+            return;
+        const node = currentItem.node;
+        const hasChildren = node.children && node.children.length > 0;
+        // 2. Right Arrow: Expand folder or move to first child
+        if (this.isRight(char)) {
+            if (hasChildren && !this.expandedNodes.has(node)) {
+                this.expandedNodes.add(node);
+                this.recalculateFlatList();
+            }
+            else if (this.cursor + 1 < this.flatList.length) {
+                this.cursor++;
+            }
+            this.render(false);
+            return;
+        }
+        // 3. Left Arrow: Collapse folder or move to parent
+        if (this.isLeft(char)) {
+            if (hasChildren && this.expandedNodes.has(node)) {
+                this.expandedNodes.delete(node);
+                this.recalculateFlatList();
+            }
+            else if (currentItem.parent) {
+                const parentIndex = this.flatList.findIndex(x => x.node === currentItem.parent);
+                if (parentIndex !== -1) {
+                    this.cursor = parentIndex;
+                }
+            }
+            this.render(false);
+            return;
+        }
+        // 4. Space: Toggle selection
+        if (char === ' ') {
+            if (!node.disabled) {
+                const newState = node.selected === true ? false : true;
+                this.setNodeState(node, newState);
+                this.render(false);
+            }
+            return;
+        }
+        // 5. Functional keys (Keep it simple to avoid blocking)
+        if (char === 'e' && hasChildren) {
+            this.toggleRecursive(node, true);
+            this.recalculateFlatList();
+            this.render(false);
+            return;
+        }
+        if (char === 'c' && hasChildren) {
+            this.toggleRecursive(node, false);
+            this.recalculateFlatList();
+            this.render(false);
+            return;
+        }
+        // 6. Submit: Enter
+        if (char === '\r' || char === '\n') {
+            const selectedValues = [];
+            this.collectSelected(this.options.data, selectedValues);
+            this.submit(selectedValues);
+        }
+    }
+    collectSelected(nodes, result) {
+        for (const node of nodes) {
+            if (node.selected === true) {
+                result.push(node.value);
+            }
+            if (node.children) {
+                this.collectSelected(node.children, result);
+            }
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.cursor = (this.cursor - 1 + this.flatList.length) % this.flatList.length;
+                this.render(false);
+            }
+            else if (event.scroll === 'down') {
+                this.cursor = (this.cursor + 1) % this.flatList.length;
+                this.render(false);
+            }
+        }
+    }
+}
+exports.TreeSelectPrompt = TreeSelectPrompt;
+TreeSelectPrompt.hasWarnedWindows = false; // Static flag to warn only once

package/dist/prompts/tree.d.ts

@@ -8,13 +8,13 @@ export declare class TreePrompt<V> extends Prompt<V, TreeOptions<V>> {
     private readonly pageSize;
     private readonly ICON_CLOSED;
     private readonly ICON_OPEN;
-    private readonly ICON_LEAF;
     constructor(options: TreeOptions<V>);
     private expandPathTo;
     private initializeExpanded;
     private recalculateFlatList;
     private traverse;
-    protected render(firstRender: boolean): void;
-    protected handleInput(char: string, key: Buffer): void;
+    private toggleRecursive;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string, _key: Buffer): void;
     protected handleMouse(event: MouseEvent): void;
 }