mepcli 0.4.0 → 0.5.5

package/dist/prompts/keypress.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeypressPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+class KeypressPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+    }
+    render(firstRender) {
+        let output = `${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}`;
+        if (this.options.keys) {
+            const hint = this.options.keys.map(k => {
+                if (k === '\r' || k === '\n' || k === 'enter')
+                    return 'enter';
+                if (k === ' ' || k === 'space')
+                    return 'space';
+                return k;
+            }).join('/');
+            // Only show hint if it's short enough to be helpful, or always?
+            // Let's always show it if provided, or maybe just dimmed.
+            output += ` ${theme_1.theme.muted}(${hint})${ansi_1.ANSI.RESET}`;
+        }
+        else {
+            output += ` ${theme_1.theme.muted}(Press any key)${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    handleInput(char, key) {
+        let keyName = char;
+        if (char === '\r' || char === '\n')
+            keyName = 'enter';
+        else if (char === ' ')
+            keyName = 'space';
+        else if (char === '\u001b')
+            keyName = 'escape';
+        else if (char === '\t')
+            keyName = 'tab';
+        // Handle backspace
+        else if (char === '\x7f' || char === '\b')
+            keyName = 'backspace';
+        // Check against whitelist
+        if (this.options.keys) {
+            const allowed = this.options.keys.map(k => k.toLowerCase());
+            // Check normalized name or exact char
+            if (!allowed.includes(keyName) && !allowed.includes(char)) {
+                return;
+            }
+        }
+        if (this.options.showInvisible) {
+            this.print(` ${theme_1.theme.success}${keyName}${ansi_1.ANSI.RESET}`);
+        }
+        this.submit(keyName);
+    }
+}
+exports.KeypressPrompt = KeypressPrompt;

package/dist/prompts/sort.d.ts

@@ -0,0 +1,14 @@
+import { Prompt } from '../base';
+import { SortOptions, MouseEvent } from '../types';
+export declare class SortPrompt extends Prompt<string[], SortOptions> {
+    private items;
+    private selectedIndex;
+    private grabbedIndex;
+    private scrollTop;
+    private readonly pageSize;
+    constructor(options: SortOptions);
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+    private swap;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/sort.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SortPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+class SortPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.selectedIndex = 0;
+        this.grabbedIndex = null;
+        this.scrollTop = 0;
+        this.pageSize = 10;
+        this.items = [...options.items];
+    }
+    render(firstRender) {
+        // Adjust Scroll Top
+        if (this.selectedIndex < this.scrollTop) {
+            this.scrollTop = this.selectedIndex;
+        }
+        else if (this.selectedIndex >= this.scrollTop + this.pageSize) {
+            this.scrollTop = this.selectedIndex - this.pageSize + 1;
+        }
+        // Ensure valid scroll (handle list shrinking?) - list doesn't shrink here but good practice
+        this.scrollTop = Math.max(0, Math.min(this.scrollTop, this.items.length - this.pageSize));
+        if (this.scrollTop < 0)
+            this.scrollTop = 0;
+        let output = '';
+        // Header
+        output += `${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${theme_1.theme.muted}(Press <space> to grab, arrows to move, <enter> to confirm)${ansi_1.ANSI.RESET}\n`;
+        const visibleItems = this.items.slice(this.scrollTop, this.scrollTop + this.pageSize);
+        visibleItems.forEach((item, index) => {
+            const actualIndex = this.scrollTop + index;
+            if (index > 0)
+                output += '\n';
+            const isSelected = actualIndex === this.selectedIndex;
+            const isGrabbed = actualIndex === this.grabbedIndex;
+            // Pointer
+            let prefix = '  ';
+            if (isSelected) {
+                if (isGrabbed) {
+                    prefix = `${theme_1.theme.main}${symbols_1.symbols.pointer}${symbols_1.symbols.pointer} `; // Double pointer for grabbed?
+                }
+                else {
+                    prefix = `${theme_1.theme.main}${symbols_1.symbols.pointer} `;
+                }
+            }
+            else if (isGrabbed) {
+                // Should not happen if we move grabbed item with cursor
+                // But if logic differs, maybe.
+            }
+            // Item Content
+            let content = item;
+            if (isGrabbed) {
+                content = `${ansi_1.ANSI.BOLD}${theme_1.theme.main}${content}${ansi_1.ANSI.RESET}`;
+            }
+            else if (isSelected) {
+                content = `${theme_1.theme.main}${content}${ansi_1.ANSI.RESET}`;
+            }
+            // Index indicator? Maybe not needed, minimalist.
+            output += `${prefix}${content}`;
+        });
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        // Enter
+        if (char === '\r' || char === '\n') {
+            this.submit(this.items);
+            return;
+        }
+        // Space (Grab/Drop)
+        if (char === ' ') {
+            if (this.grabbedIndex === null) {
+                this.grabbedIndex = this.selectedIndex;
+            }
+            else {
+                this.grabbedIndex = null;
+            }
+            this.render(false);
+            return;
+        }
+        // Up
+        if (this.isUp(char)) {
+            if (this.grabbedIndex !== null) {
+                // Move item up
+                if (this.selectedIndex > 0) {
+                    const newIndex = this.selectedIndex - 1;
+                    this.swap(this.selectedIndex, newIndex);
+                    this.selectedIndex = newIndex;
+                    this.grabbedIndex = newIndex;
+                }
+            }
+            else {
+                // Move cursor up
+                this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.items.length - 1;
+            }
+            this.render(false);
+            return;
+        }
+        // Down
+        if (this.isDown(char)) {
+            if (this.grabbedIndex !== null) {
+                // Move item down
+                if (this.selectedIndex < this.items.length - 1) {
+                    const newIndex = this.selectedIndex + 1;
+                    this.swap(this.selectedIndex, newIndex);
+                    this.selectedIndex = newIndex;
+                    this.grabbedIndex = newIndex;
+                }
+            }
+            else {
+                // Move cursor down
+                this.selectedIndex = this.selectedIndex < this.items.length - 1 ? this.selectedIndex + 1 : 0;
+            }
+            this.render(false);
+            return;
+        }
+    }
+    swap(i, j) {
+        [this.items[i], this.items[j]] = [this.items[j], this.items[i]];
+    }
+    // Mouse support? 
+    // Drag and drop is hard with just clicks/scroll. 
+    // Maybe click to grab, scroll to move?
+    handleMouse(event) {
+        // Simple scroll support for navigation
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                if (this.grabbedIndex !== null) {
+                    if (this.selectedIndex > 0) {
+                        const newIndex = this.selectedIndex - 1;
+                        this.swap(this.selectedIndex, newIndex);
+                        this.selectedIndex = newIndex;
+                        this.grabbedIndex = newIndex;
+                    }
+                }
+                else {
+                    this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.items.length - 1;
+                }
+                this.render(false);
+            }
+            else if (event.scroll === 'down') {
+                if (this.grabbedIndex !== null) {
+                    if (this.selectedIndex < this.items.length - 1) {
+                        const newIndex = this.selectedIndex + 1;
+                        this.swap(this.selectedIndex, newIndex);
+                        this.selectedIndex = newIndex;
+                        this.grabbedIndex = newIndex;
+                    }
+                }
+                else {
+                    this.selectedIndex = this.selectedIndex < this.items.length - 1 ? this.selectedIndex + 1 : 0;
+                }
+                this.render(false);
+            }
+        }
+    }
+}
+exports.SortPrompt = SortPrompt;

package/dist/prompts/table.d.ts

@@ -0,0 +1,14 @@
+import { Prompt } from '../base';
+import { TableOptions, MouseEvent } from '../types';
+export declare class TablePrompt<V> extends Prompt<V, TableOptions<V>> {
+    private selectedIndex;
+    private scrollTop;
+    private readonly pageSize;
+    private colWidths;
+    constructor(options: TableOptions<V>);
+    private calculateColWidths;
+    protected render(firstRender: boolean): void;
+    private pad;
+    protected handleInput(char: string): void;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/table.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TablePrompt = 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 TablePrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.selectedIndex = 0;
+        this.scrollTop = 0;
+        this.colWidths = [];
+        this.pageSize = options.rows || 7;
+        this.calculateColWidths();
+    }
+    calculateColWidths() {
+        const { columns, data } = this.options;
+        this.colWidths = columns.map(c => (0, utils_1.stringWidth)(c));
+        data.forEach(row => {
+            row.row.forEach((cell, idx) => {
+                if (idx < this.colWidths.length) {
+                    this.colWidths[idx] = Math.max(this.colWidths[idx], (0, utils_1.stringWidth)(cell));
+                }
+            });
+        });
+        // Add padding
+        this.colWidths = this.colWidths.map(w => w + 2);
+    }
+    render(firstRender) {
+        // Scroll Logic
+        if (this.selectedIndex < this.scrollTop) {
+            this.scrollTop = this.selectedIndex;
+        }
+        else if (this.selectedIndex >= this.scrollTop + this.pageSize) {
+            this.scrollTop = this.selectedIndex - this.pageSize + 1;
+        }
+        const maxScroll = Math.max(0, this.options.data.length - this.pageSize);
+        this.scrollTop = Math.min(this.scrollTop, maxScroll);
+        let output = '';
+        // Title
+        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`;
+        // Table Header
+        let headerStr = '  '; // Indent for pointer space
+        this.options.columns.forEach((col, i) => {
+            headerStr += this.pad(col, this.colWidths[i]);
+        });
+        output += `${ansi_1.ANSI.BOLD}${headerStr}${ansi_1.ANSI.RESET}\n`;
+        // Table Body
+        const visibleRows = this.options.data.slice(this.scrollTop, this.scrollTop + this.pageSize);
+        visibleRows.forEach((item, index) => {
+            const actualIndex = this.scrollTop + index;
+            if (index > 0)
+                output += '\n';
+            const isSelected = actualIndex === this.selectedIndex;
+            const pointer = isSelected ? `${theme_1.theme.main}${symbols_1.symbols.pointer}${ansi_1.ANSI.RESET} ` : '  ';
+            let rowStr = '';
+            item.row.forEach((cell, colIdx) => {
+                const width = this.colWidths[colIdx];
+                let cellStr = this.pad(cell, width);
+                if (isSelected) {
+                    cellStr = `${theme_1.theme.main}${cellStr}${ansi_1.ANSI.RESET}`;
+                }
+                rowStr += cellStr;
+            });
+            output += `${pointer}${rowStr}`;
+        });
+        this.renderFrame(output);
+    }
+    pad(str, width) {
+        const len = (0, utils_1.stringWidth)(str);
+        if (len >= width)
+            return str;
+        return str + ' '.repeat(width - len);
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            this.submit(this.options.data[this.selectedIndex].value);
+            return;
+        }
+        if (this.isUp(char)) {
+            this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.options.data.length - 1;
+            this.render(false);
+            return;
+        }
+        if (this.isDown(char)) {
+            this.selectedIndex = this.selectedIndex < this.options.data.length - 1 ? this.selectedIndex + 1 : 0;
+            this.render(false);
+            return;
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.options.data.length - 1;
+                this.render(false);
+            }
+            else if (event.scroll === 'down') {
+                this.selectedIndex = this.selectedIndex < this.options.data.length - 1 ? this.selectedIndex + 1 : 0;
+                this.render(false);
+            }
+        }
+    }
+}
+exports.TablePrompt = TablePrompt;

package/dist/prompts/text.js

@@ -52,22 +52,22 @@ class TextPrompt extends base_1.Prompt {
             // This is tricky because segments might contain '\n'.
             // safeSplit treats '\n' as a segment.
             let cursorLineIndex = 0;
-            let cursorSegmentIndexOnLine = 0;
-            let currentSegmentIndex = 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
-                let lineSegmentsCount = 0;
+                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;
-            let colIndex = 0; // Visual column or char index?
+            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++) {
@@ -90,7 +90,7 @@ class TextPrompt extends base_1.Prompt {
             // Now prepare lines for display (scrolling/truncation)
             // We need to reconstruct lines from segments to apply styling/truncation logic per line.
             let currentLineSegments = [];
-            let processedLines = []; // Array of segment arrays
+            const processedLines = []; // Array of segment arrays
             for (const seg of this.segments) {
                 if (seg === '\n') {
                     processedLines.push(currentLineSegments);
@@ -118,25 +118,6 @@ class TextPrompt extends base_1.Prompt {
                 // But cursorRelativeCol is global? No, we reset it on newline.
                 // So cursorRelativeCol above was correct for the current line.
                 if (isCursorLine) {
-                    // Check if we need to scroll
-                    // We need visual width of the line up to cursor.
-                    // cursorRelativeCol holds that.
-                    // If visual position > maxContentLen, we scroll.
-                    // This logic is similar to before but needs to use widths.
-                    // For simplicity, let's stick to the previous slice logic but apply it to SEGMENTS if possible.
-                    // But slicing segments for display is safer.
-                    // Let's implement simple tail truncation for now to keep it robust.
-                    // Ideally we scroll, but scrolling with variable width chars is complex.
-                    // "Good Enough": if it fits, show it. If not, truncate end.
-                    // If cursor is beyond end, scroll (slice from left).
-                    // Simplified: just show visibleLine truncated by base class renderFrame?
-                    // But renderFrame truncates blindly. We want the cursor visible.
-                    // Let's leave scrolling out for this specific "Backspace" fix task unless it's critical.
-                    // The user asked for "Backspace Emoji fix".
-                    // The scrolling logic is secondary but important.
-                    // I will preserve the existing simple scrolling logic but using segments?
-                    // No, let's just use the string for display and let renderFrame truncate.
-                    // Fix: Ensure we don't crash or show garbage.
                 }
                 displayValueLines.push(theme_1.theme.main + visibleLine + ansi_1.ANSI.RESET);
             });

package/dist/prompts/tree.d.ts

@@ -0,0 +1,20 @@
+import { Prompt } from '../base';
+import { TreeOptions, MouseEvent } from '../types';
+export declare class TreePrompt<V> extends Prompt<V, TreeOptions<V>> {
+    private cursor;
+    private expandedNodes;
+    private flatList;
+    private scrollTop;
+    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;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/tree.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreePrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+class TreePrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.cursor = 0;
+        this.expandedNodes = new Set();
+        this.flatList = [];
+        this.scrollTop = 0;
+        this.pageSize = 15;
+        // Icons
+        this.ICON_CLOSED = symbols_1.symbols.pointer === '>' ? '+' : '▸';
+        this.ICON_OPEN = symbols_1.symbols.pointer === '>' ? '-' : '▾';
+        this.ICON_LEAF = symbols_1.symbols.pointer === '>' ? ' ' : ' '; // No specific icon for leaf, just indentation
+        this.initializeExpanded(this.options.data);
+        // Handle initial value
+        if (this.options.initial !== undefined) {
+            this.expandPathTo(this.options.initial);
+        }
+        this.recalculateFlatList();
+        if (this.options.initial !== undefined) {
+            const index = this.flatList.findIndex(item => item.node.value === this.options.initial);
+            if (index !== -1) {
+                this.cursor = index;
+            }
+        }
+    }
+    expandPathTo(value) {
+        const find = (nodes) => {
+            for (const node of nodes) {
+                if (node.value === value)
+                    return true;
+                if (node.children) {
+                    if (find(node.children)) {
+                        this.expandedNodes.add(node);
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+        find(this.options.data);
+    }
+    initializeExpanded(nodes) {
+        for (const node of nodes) {
+            if (node.expanded) {
+                this.expandedNodes.add(node);
+            }
+            if (node.children) {
+                this.initializeExpanded(node.children);
+            }
+        }
+    }
+    recalculateFlatList() {
+        this.flatList = [];
+        this.traverse(this.options.data, 0, null);
+        // Adjust cursor if it went out of bounds (e.g. collapsing a folder above cursor)
+        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);
+            }
+        }
+    }
+    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;
+        }
+        // Adjust Scroll
+        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;
+            // Indentation
+            const indentSize = this.options.indent || 2;
+            const indentation = ' '.repeat(item.depth * indentSize);
+            // Pointer
+            let linePrefix = '';
+            if (isSelected) {
+                linePrefix = `${theme_1.theme.main}${symbols_1.symbols.pointer} `;
+            }
+            else {
+                linePrefix = '  ';
+            }
+            // Folder Icon
+            let icon = '  '; // Default 2 spaces for alignment
+            const hasChildren = item.node.children && item.node.children.length > 0;
+            if (hasChildren) {
+                if (this.expandedNodes.has(item.node)) {
+                    icon = `${this.ICON_OPEN} `;
+                }
+                else {
+                    icon = `${this.ICON_CLOSED} `;
+                }
+            }
+            // Title
+            let title = item.node.title;
+            if (item.node.disabled) {
+                title = `${theme_1.theme.muted}${title} (disabled)${ansi_1.ANSI.RESET}`;
+            }
+            // Compose line
+            let line = `${indentation}${icon}${title}`;
+            if (isSelected) {
+                line = `${theme_1.theme.main}${line}${ansi_1.ANSI.RESET}`;
+            }
+            output += linePrefix + line;
+            if (index < visible.length - 1)
+                output += '\n';
+        });
+        this.renderFrame(output);
+    }
+    handleInput(char, key) {
+        if (this.flatList.length === 0)
+            return;
+        // Navigation
+        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];
+        const node = currentItem.node;
+        const hasChildren = node.children && node.children.length > 0;
+        // Right: Expand or Go Down
+        if (this.isRight(char)) {
+            if (hasChildren) {
+                if (!this.expandedNodes.has(node)) {
+                    this.expandedNodes.add(node);
+                    this.recalculateFlatList();
+                }
+                else {
+                    // Go to first child (next item in flat list)
+                    if (this.cursor + 1 < this.flatList.length) {
+                        this.cursor++;
+                    }
+                }
+                this.render(false);
+                return;
+            }
+        }
+        // Left: Collapse or Go Up (Parent)
+        if (this.isLeft(char)) {
+            if (hasChildren && this.expandedNodes.has(node)) {
+                this.expandedNodes.delete(node);
+                this.recalculateFlatList();
+                this.render(false);
+                return;
+            }
+            else {
+                // Go to parent
+                if (currentItem.parent) {
+                    const parentIndex = this.flatList.findIndex(x => x.node === currentItem.parent);
+                    if (parentIndex !== -1) {
+                        this.cursor = parentIndex;
+                        this.render(false);
+                        return;
+                    }
+                }
+            }
+        }
+        // Toggle (Space)
+        if (char === ' ') {
+            if (hasChildren) {
+                if (this.expandedNodes.has(node)) {
+                    this.expandedNodes.delete(node);
+                }
+                else {
+                    this.expandedNodes.add(node);
+                }
+                this.recalculateFlatList();
+                this.render(false);
+            }
+            return;
+        }
+        // Submit (Enter)
+        if (char === '\r' || char === '\n') {
+            if (!node.disabled) {
+                this.submit(node.value);
+            }
+        }
+    }
+    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.TreePrompt = TreePrompt;