mepcli 0.6.1 → 1.0.0-beta.2

package/dist/prompts/match.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchPrompt = 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 MatchPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        // Links: Source ID -> Set of Target IDs
+        this.links = new Map();
+        this.cursorSource = 0;
+        this.cursorTarget = 0;
+        this.scrollTopSource = 0;
+        this.scrollTopTarget = 0;
+        this.activeSide = 'source';
+        this.pickedSourceIndex = null;
+        this.pageSize = 10;
+        this.source = this.normalize(options.source);
+        this.target = this.normalize(options.target);
+    }
+    normalize(items) {
+        return items.map(item => {
+            if (typeof item === 'string') {
+                return { id: item, label: item, value: item };
+            }
+            return item;
+        });
+    }
+    render(_firstRender) {
+        const termWidth = process.stdout.columns || 80;
+        const colWidth = Math.floor((termWidth - 8) / 2); // -8 for middle spacing and borders
+        // Adjust Scroll Top
+        if (this.activeSide === 'source') {
+            if (this.cursorSource < this.scrollTopSource)
+                this.scrollTopSource = this.cursorSource;
+            if (this.cursorSource >= this.scrollTopSource + this.pageSize)
+                this.scrollTopSource = this.cursorSource - this.pageSize + 1;
+        }
+        else {
+            if (this.cursorTarget < this.scrollTopTarget)
+                this.scrollTopTarget = this.cursorTarget;
+            if (this.cursorTarget >= this.scrollTopTarget + this.pageSize)
+                this.scrollTopTarget = this.cursorTarget - 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 sourceTitle = this.activeSide === 'source' ? `${theme_1.theme.main}Source${ansi_1.ANSI.RESET}` : 'Source';
+        const targetTitle = this.activeSide === 'target' ? `${theme_1.theme.main}Target${ansi_1.ANSI.RESET}` : 'Target';
+        output += `  ${sourceTitle}`.padEnd(colWidth + 2) + '    ' + `  ${targetTitle}\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`;
+        // Render Rows
+        for (let i = 0; i < this.pageSize; i++) {
+            const idxSource = this.scrollTopSource + i;
+            const idxTarget = this.scrollTopTarget + i;
+            const itemSource = this.source[idxSource];
+            const itemTarget = this.target[idxTarget];
+            // Source Column
+            let sourceStr = '';
+            if (itemSource) {
+                const isSelected = this.activeSide === 'source' && idxSource === this.cursorSource;
+                const isPicked = this.pickedSourceIndex === idxSource;
+                const hasLinks = this.links.has(itemSource.id) && this.links.get(itemSource.id).size > 0;
+                let prefix = '  ';
+                if (isSelected)
+                    prefix = `${theme_1.theme.main}${symbols_1.symbols.pointer} `;
+                if (isPicked)
+                    prefix = `${theme_1.theme.success}${symbols_1.symbols.pointer} `;
+                let title = this.truncate(itemSource.label, colWidth - 4);
+                // Color logic
+                if (isPicked) {
+                    title = `${theme_1.theme.success}${title}${ansi_1.ANSI.RESET}`;
+                }
+                else if (hasLinks) {
+                    title = `${theme_1.theme.success}${title}${ansi_1.ANSI.RESET}`;
+                }
+                else if (isSelected) {
+                    title = `${ansi_1.ANSI.FG_CYAN}${title}${ansi_1.ANSI.RESET}`;
+                }
+                // Indicator for links
+                const linkIndicator = hasLinks ? `${theme_1.theme.success}*${ansi_1.ANSI.RESET}` : ' ';
+                sourceStr = `${prefix}${title} ${linkIndicator}`;
+                // Highlight connected targets?
+                if (isSelected || isPicked) {
+                    // This is handled in Target render
+                }
+            }
+            else {
+                sourceStr = '';
+            }
+            // Target Column
+            let targetStr = '';
+            if (itemTarget) {
+                const isSelected = this.activeSide === 'target' && idxTarget === this.cursorTarget;
+                // Determine if this target is linked to the RELEVANT source
+                // Relevant source is: Picked Source OR (if none picked) Cursor Source
+                const relevantSourceIdx = this.pickedSourceIndex !== null ? this.pickedSourceIndex : this.cursorSource;
+                const relevantSource = this.source[relevantSourceIdx];
+                let isLinkedToRelevant = false;
+                let isLinkedToAny = false;
+                // Check links
+                for (const [sId, tIds] of Array.from(this.links.entries())) {
+                    if (tIds.has(itemTarget.id)) {
+                        isLinkedToAny = true;
+                        if (relevantSource && sId === relevantSource.id) {
+                            isLinkedToRelevant = true;
+                        }
+                    }
+                }
+                let prefix = '  ';
+                if (isSelected)
+                    prefix = `${theme_1.theme.main}${symbols_1.symbols.pointer} `;
+                let title = this.truncate(itemTarget.label, colWidth - 4);
+                if (isLinkedToRelevant) {
+                    title = `${theme_1.theme.success}${title}${ansi_1.ANSI.RESET}`;
+                }
+                else if (isLinkedToAny) {
+                    // Linked to someone else
+                    title = `${ansi_1.ANSI.DIM}${title}${ansi_1.ANSI.RESET}`;
+                }
+                else if (isSelected) {
+                    title = `${ansi_1.ANSI.FG_CYAN}${title}${ansi_1.ANSI.RESET}`;
+                }
+                // Indicator
+                const linkIndicator = isLinkedToRelevant ? `${theme_1.theme.success}<=${ansi_1.ANSI.RESET}` : (isLinkedToAny ? `${ansi_1.ANSI.DIM}<=${ansi_1.ANSI.RESET}` : '  ');
+                targetStr = `${linkIndicator} ${prefix}${title}`;
+            }
+            // Pad Source
+            const sourceVisualLen = itemSource ? ((0, utils_1.stringWidth)(this.stripAnsi(sourceStr))) : 0;
+            const padding = ' '.repeat(Math.max(0, colWidth - sourceVisualLen + 2)); // +2 extra space
+            output += sourceStr + padding + '    ' + targetStr + '\n';
+        }
+        // Instructions
+        if (this.pickedSourceIndex !== null) {
+            output += `\n${theme_1.theme.success}Linking: ${this.source[this.pickedSourceIndex].label}${ansi_1.ANSI.RESET}`;
+            output += `\n${ansi_1.ANSI.DIM}Select Target to Link/Unlink. Esc to Cancel.${ansi_1.ANSI.RESET}`;
+        }
+        else {
+            output += `\n${ansi_1.ANSI.DIM}Space to Pick Source, Enter to Submit.${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        // Navigation
+        if (this.isUp(char)) {
+            if (this.activeSide === 'source') {
+                this.cursorSource = Math.max(0, this.cursorSource - 1);
+            }
+            else {
+                this.cursorTarget = Math.max(0, this.cursorTarget - 1);
+            }
+            this.render(false);
+            return;
+        }
+        if (this.isDown(char)) {
+            if (this.activeSide === 'source') {
+                this.cursorSource = Math.min(this.source.length - 1, this.cursorSource + 1);
+            }
+            else {
+                this.cursorTarget = Math.min(this.target.length - 1, this.cursorTarget + 1);
+            }
+            this.render(false);
+            return;
+        }
+        // Space: Action
+        if (char === ' ') {
+            if (this.activeSide === 'source') {
+                // Pick Source
+                this.pickedSourceIndex = this.cursorSource;
+                this.activeSide = 'target';
+                // Try to find first linked target or stay at top?
+                // Stay at top or current pos is fine.
+            }
+            else {
+                // Toggle Link
+                if (this.pickedSourceIndex !== null) {
+                    const sId = this.source[this.pickedSourceIndex].id;
+                    const tId = this.target[this.cursorTarget].id;
+                    if (!this.links.has(sId)) {
+                        this.links.set(sId, new Set());
+                    }
+                    const sourceLinks = this.links.get(sId);
+                    if (sourceLinks.has(tId)) {
+                        // Unlink
+                        sourceLinks.delete(tId);
+                    }
+                    else {
+                        // Link
+                        if (this.options.constraints?.oneToMany === false) {
+                            for (const [otherSId, tIds] of Array.from(this.links.entries())) {
+                                if (otherSId !== sId && tIds.has(tId)) {
+                                    tIds.delete(tId);
+                                }
+                            }
+                        }
+                        sourceLinks.add(tId);
+                    }
+                    // Stay in Target side to allow picking more?
+                }
+            }
+            this.render(false);
+            return;
+        }
+        // Enter
+        if (char === '\r' || char === '\n') {
+            // Check Required Constraint
+            if (this.options.constraints?.required) {
+                // Check if all sources have at least one link
+                const allLinked = this.source.every(s => {
+                    return this.links.has(s.id) && this.links.get(s.id).size > 0;
+                });
+                if (!allLinked) {
+                    return;
+                }
+            }
+            // Submit Result: Record<SourceID, TargetValue[]>
+            const result = {};
+            for (const [sId, tIds] of Array.from(this.links.entries())) {
+                if (tIds.size > 0) {
+                    // Map Target IDs back to Values
+                    const values = Array.from(tIds).map(tid => {
+                        return this.target.find(t => t.id === tid)?.value;
+                    });
+                    result[sId] = values;
+                }
+            }
+            this.submit(result);
+            return;
+        }
+        // Escape / Backspace to go back to Source
+        if (char === '\u001b' || char === '\u0008' || char === '\x7f' || char === 'h') { // h for vim left
+            if (this.activeSide === 'target') {
+                this.activeSide = 'source';
+                this.pickedSourceIndex = null;
+                this.render(false);
+            }
+            return;
+        }
+        // Tab
+        if (char === '\t') {
+            this.activeSide = this.activeSide === 'source' ? 'target' : 'source';
+            // If switching to target without picking, pickedIndex is null.
+            // Just viewing mode.
+            if (this.activeSide === 'source') {
+                this.pickedSourceIndex = null;
+            }
+            this.render(false);
+            return;
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                if (this.activeSide === 'source') {
+                    this.cursorSource = Math.max(0, this.cursorSource - 1);
+                }
+                else {
+                    this.cursorTarget = Math.max(0, this.cursorTarget - 1);
+                }
+            }
+            else {
+                if (this.activeSide === 'source') {
+                    this.cursorSource = Math.min(this.source.length - 1, this.cursorSource + 1);
+                }
+                else {
+                    this.cursorTarget = Math.min(this.target.length - 1, this.cursorTarget + 1);
+                }
+            }
+            this.render(false);
+        }
+    }
+}
+exports.MatchPrompt = MatchPrompt;

package/dist/prompts/miller.d.ts

@@ -0,0 +1,15 @@
+import { Prompt } from '../base';
+import { MillerOptions, MouseEvent } from '../types';
+export declare class MillerPrompt<V> extends Prompt<V[], MillerOptions<V>> {
+    private selections;
+    private activeCol;
+    private scrollTops;
+    private colWidth;
+    private visibleCols;
+    constructor(options: MillerOptions<V>);
+    private calculateLayout;
+    private getColumnData;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string): void;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/miller.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MillerPrompt = void 0;
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const ansi_1 = require("../ansi");
+const symbols_1 = require("../symbols");
+const utils_1 = require("../utils");
+class MillerPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.selections = [];
+        this.activeCol = 0;
+        this.scrollTops = []; // Scroll position for each column
+        // Layout
+        this.colWidth = 0;
+        this.visibleCols = 3;
+        this.selections = [0];
+        this.scrollTops = [0];
+        // TODO: Map initial values to selections if provided
+        this.calculateLayout();
+    }
+    calculateLayout() {
+        const termWidth = process.stdout.columns || 80;
+        // We aim for 3 columns? Or based on width?
+        // Minimum width per column ~ 20?
+        this.visibleCols = Math.floor(termWidth / 20);
+        if (this.visibleCols < 1)
+            this.visibleCols = 1;
+        if (this.visibleCols > 4)
+            this.visibleCols = 4; // Cap at 4
+        this.colWidth = Math.floor((termWidth - 4) / this.visibleCols); // -4 for margins
+    }
+    getColumnData(depth) {
+        let current = this.options.data;
+        for (let i = 0; i < depth; i++) {
+            const sel = this.selections[i];
+            if (current[sel] && current[sel].children) {
+                current = current[sel].children;
+            }
+            else {
+                return undefined;
+            }
+        }
+        return current;
+    }
+    render(_firstRender) {
+        let output = '';
+        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`;
+        let startCol = 0;
+        if (this.activeCol >= this.visibleCols) {
+            startCol = this.activeCol - this.visibleCols + 1;
+        }
+        // Construct columns content
+        const columnsToRender = [];
+        for (let c = startCol; c < startCol + this.visibleCols; c++) {
+            const data = this.getColumnData(c);
+            if (!data)
+                break;
+            const rows = [];
+            const selectedIdx = this.selections[c] ?? -1;
+            const isFocusedCol = c === this.activeCol;
+            // Scroll handling
+            const pageSize = 10; // Fixed height for now
+            if (!this.scrollTops[c])
+                this.scrollTops[c] = 0;
+            if (selectedIdx !== -1) {
+                if (selectedIdx < this.scrollTops[c]) {
+                    this.scrollTops[c] = selectedIdx;
+                }
+                else if (selectedIdx >= this.scrollTops[c] + pageSize) {
+                    this.scrollTops[c] = selectedIdx - pageSize + 1;
+                }
+            }
+            // Render rows
+            const start = this.scrollTops[c];
+            const end = Math.min(data.length, start + pageSize);
+            for (let i = start; i < end; i++) {
+                const item = data[i];
+                const isSelected = i === selectedIdx;
+                const isFocused = isSelected && isFocusedCol;
+                let prefix = ' ';
+                if (isSelected) {
+                    prefix = isFocused ? `${theme_1.theme.main}${symbols_1.symbols.pointer}${ansi_1.ANSI.RESET}` : `${theme_1.theme.muted}${symbols_1.symbols.pointer}${ansi_1.ANSI.RESET}`;
+                }
+                let title = item.title;
+                // Truncate
+                if ((0, utils_1.stringWidth)(title) > this.colWidth - 4) {
+                    title = title.slice(0, this.colWidth - 5) + '…';
+                }
+                let line = `${prefix} ${isSelected && isFocused ? theme_1.theme.main : ''}${title}${ansi_1.ANSI.RESET}`;
+                // Add arrow if children exist
+                if (item.children && item.children.length > 0) {
+                    const pad = this.colWidth - (0, utils_1.stringWidth)((0, utils_1.stripAnsi)(line)) - 2;
+                    line += ' '.repeat(Math.max(0, pad)) + `${theme_1.theme.muted}>${ansi_1.ANSI.RESET}`;
+                }
+                rows.push(line);
+            }
+            // Pad column to pageSize
+            while (rows.length < pageSize) {
+                rows.push('');
+            }
+            columnsToRender.push(rows);
+        }
+        // Combine columns side by side
+        const rowCount = 10;
+        for (let r = 0; r < rowCount; r++) {
+            let line = '';
+            for (let c = 0; c < columnsToRender.length; c++) {
+                let cell = columnsToRender[c][r] || '';
+                // Pad cell
+                const len = (0, utils_1.stringWidth)((0, utils_1.stripAnsi)(cell));
+                const pad = this.colWidth - len;
+                cell += ' '.repeat(Math.max(0, pad));
+                line += cell;
+                // Separator
+                if (c < columnsToRender.length - 1) {
+                    line += `${theme_1.theme.muted}│${ansi_1.ANSI.RESET} `;
+                }
+            }
+            output += line + '\n';
+        }
+        // Breadcrumbs / Status
+        const pathTitles = [];
+        for (let i = 0; i <= this.activeCol; i++) {
+            const data = this.getColumnData(i);
+            if (data && typeof this.selections[i] === 'number') {
+                pathTitles.push(data[this.selections[i]].title);
+            }
+        }
+        output += `${theme_1.theme.muted}Path: ${pathTitles.join(' / ')}${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        const currentData = this.getColumnData(this.activeCol);
+        if (!currentData)
+            return; // Should not happen
+        // Enter
+        if (char === '\r' || char === '\n') {
+            // Collect values
+            const values = [];
+            for (let i = 0; i <= this.activeCol; i++) {
+                const d = this.getColumnData(i);
+                if (d)
+                    values.push(d[this.selections[i]].value);
+            }
+            this.submit(values);
+            return;
+        }
+        if (this.isUp(char)) {
+            if (this.selections[this.activeCol] > 0) {
+                this.selections[this.activeCol]--;
+                // Reset subsequent columns
+                this.selections = this.selections.slice(0, this.activeCol + 1);
+            }
+            else {
+                this.selections[this.activeCol] = currentData.length - 1;
+                this.selections = this.selections.slice(0, this.activeCol + 1);
+            }
+            this.render(false);
+            return;
+        }
+        if (this.isDown(char)) {
+            if (this.selections[this.activeCol] < currentData.length - 1) {
+                this.selections[this.activeCol]++;
+                this.selections = this.selections.slice(0, this.activeCol + 1);
+            }
+            else {
+                this.selections[this.activeCol] = 0;
+                this.selections = this.selections.slice(0, this.activeCol + 1);
+            }
+            this.render(false);
+            return;
+        }
+        if (this.isRight(char) || char === '\t') {
+            // Expand
+            const idx = this.selections[this.activeCol];
+            const item = currentData[idx];
+            if (item.children && item.children.length > 0) {
+                this.activeCol++;
+                this.selections[this.activeCol] = 0;
+                this.render(false);
+            }
+            return;
+        }
+        if (this.isLeft(char) || char === '\x1b[Z') {
+            if (this.activeCol > 0) {
+                this.activeCol--;
+                this.render(false);
+            }
+            return;
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            const currentData = this.getColumnData(this.activeCol);
+            if (!currentData || currentData.length === 0)
+                return;
+            if (event.scroll === 'up') {
+                if (this.selections[this.activeCol] > 0) {
+                    this.selections[this.activeCol]--;
+                }
+                else {
+                    this.selections[this.activeCol] = currentData.length - 1;
+                }
+            }
+            else if (event.scroll === 'down') {
+                if (this.selections[this.activeCol] < currentData.length - 1) {
+                    this.selections[this.activeCol]++;
+                }
+                else {
+                    this.selections[this.activeCol] = 0;
+                }
+            }
+            // Reset subsequent columns
+            this.selections = this.selections.slice(0, this.activeCol + 1);
+            this.render(false);
+        }
+    }
+}
+exports.MillerPrompt = MillerPrompt;

package/dist/prompts/multi-column-select.d.ts

@@ -0,0 +1,10 @@
+import { SelectPrompt } from './select';
+import { MultiColumnSelectOptions } from '../types';
+export declare class MultiColumnSelectPrompt<V> extends SelectPrompt<V, MultiColumnSelectOptions<V>> {
+    private cols;
+    private colWidth;
+    constructor(options: MultiColumnSelectOptions<V>);
+    private calculateLayout;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}

package/dist/prompts/multi-column-select.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiColumnSelectPrompt = void 0;
+const select_1 = require("./select");
+const theme_1 = require("../theme");
+const ansi_1 = require("../ansi");
+const utils_1 = require("../utils");
+const symbols_1 = require("../symbols");
+class MultiColumnSelectPrompt extends select_1.SelectPrompt {
+    constructor(options) {
+        super(options);
+        this.cols = 1;
+        this.colWidth = 0;
+        this.calculateLayout();
+    }
+    calculateLayout() {
+        const termWidth = process.stdout.columns || 80;
+        const choices = this.options.choices.filter(c => !this.isSeparator(c));
+        if (choices.length === 0) {
+            this.cols = 1;
+            this.colWidth = termWidth;
+            return;
+        }
+        // Calculate max item width
+        let maxLen = 0;
+        for (const c of choices) {
+            const len = (0, utils_1.stringWidth)(c.title);
+            if (len > maxLen)
+                maxLen = len;
+        }
+        // Add padding (pointer + space + item + space)
+        const itemWidth = maxLen + 4;
+        if (typeof this.options.cols === 'number') {
+            this.cols = this.options.cols;
+        }
+        else {
+            // Auto
+            this.cols = Math.floor(termWidth / itemWidth);
+            if (this.cols < 1)
+                this.cols = 1;
+        }
+        // Final column width
+        this.colWidth = Math.floor(termWidth / this.cols);
+    }
+    render(_firstRender) {
+        let output = '';
+        const choices = this.getFilteredChoices();
+        // Header
+        const searchStr = this.searchBuffer ? ` ${theme_1.theme.muted}(Filter: ${this.searchBuffer})${ansi_1.ANSI.RESET}` : '';
+        output += `${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}${searchStr}\n`;
+        if (choices.length === 0) {
+            output += `  ${theme_1.theme.muted}No results found${ansi_1.ANSI.RESET}`;
+            this.renderFrame(output);
+            return;
+        }
+        // Grid Render
+        const totalRows = Math.ceil(choices.length / this.cols);
+        // Adjust Scroll
+        const currentRow = Math.floor(this.selectedIndex / this.cols);
+        if (currentRow < this.scrollTop) {
+            this.scrollTop = currentRow;
+        }
+        else if (currentRow >= this.scrollTop + this.pageSize) {
+            this.scrollTop = currentRow - this.pageSize + 1;
+        }
+        // Edge case: if list shrinks
+        if (this.scrollTop > totalRows - 1) {
+            this.scrollTop = Math.max(0, totalRows - this.pageSize);
+        }
+        const startRow = this.scrollTop;
+        const endRow = Math.min(totalRows, startRow + this.pageSize);
+        for (let r = startRow; r < endRow; r++) {
+            let rowStr = '';
+            for (let c = 0; c < this.cols; c++) {
+                const idx = r * this.cols + c;
+                if (idx >= choices.length)
+                    break;
+                const choice = choices[idx];
+                // Truncate if needed
+                let title = choice.title || '';
+                if ((0, utils_1.stringWidth)(title) > this.colWidth - 3) {
+                    title = title.slice(0, this.colWidth - 4) + '…';
+                }
+                let cellContent = '';
+                if (idx === this.selectedIndex) {
+                    cellContent = `${theme_1.theme.main}${symbols_1.symbols.pointer} ${title}${ansi_1.ANSI.RESET}`;
+                }
+                else {
+                    cellContent = `  ${title}`;
+                }
+                // Pad cell to colWidth
+                const currentWidth = (0, utils_1.stringWidth)(this.stripAnsi(cellContent));
+                const padding = Math.max(0, this.colWidth - currentWidth);
+                // Add cell to row
+                rowStr += cellContent + ' '.repeat(padding);
+            }
+            output += rowStr + '\n';
+        }
+        // Remove trailing newline
+        if (output.endsWith('\n'))
+            output = output.slice(0, -1);
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        const choices = this.getFilteredChoices();
+        if (char === '\r' || char === '\n') {
+            if (choices.length > 0) {
+                this.submit(choices[this.selectedIndex].value);
+            }
+            return;
+        }
+        if (this.isUp(char)) {
+            const newIndex = this.selectedIndex - this.cols;
+            if (newIndex >= 0) {
+                this.selectedIndex = newIndex;
+            }
+            this.render(false);
+            return;
+        }
+        if (this.isDown(char)) {
+            const newIndex = this.selectedIndex + this.cols;
+            if (newIndex < choices.length) {
+                this.selectedIndex = newIndex;
+            }
+            this.render(false);
+            return;
+        }
+        if (this.isLeft(char)) {
+            if (this.selectedIndex > 0) {
+                this.selectedIndex--;
+            }
+            else {
+                this.selectedIndex = choices.length - 1;
+            }
+            this.render(false);
+            return;
+        }
+        if (this.isRight(char)) {
+            if (this.selectedIndex < choices.length - 1) {
+                this.selectedIndex++;
+            }
+            else {
+                this.selectedIndex = 0;
+            }
+            this.render(false);
+            return;
+        }
+        // Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            if (this.searchBuffer.length > 0) {
+                this.searchBuffer = this.searchBuffer.slice(0, -1);
+                this.selectedIndex = 0;
+                this.calculateLayout();
+                this.render(false);
+            }
+            return;
+        }
+        // Typing
+        if (char.length === 1 && !/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            this.searchBuffer += char;
+            this.selectedIndex = 0;
+            this.render(false);
+        }
+    }
+}
+exports.MultiColumnSelectPrompt = MultiColumnSelectPrompt;