mepcli 0.2.1 → 0.2.5

package/dist/prompts/checkbox.d.ts

@@ -0,0 +1,10 @@
+import { Prompt } from '../base';
+import { CheckboxOptions } from '../types';
+export declare class CheckboxPrompt extends Prompt<any[], CheckboxOptions> {
+    private selectedIndex;
+    private checkedState;
+    private errorMsg;
+    constructor(options: CheckboxOptions);
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}

package/dist/prompts/checkbox.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckboxPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+// --- Implementation: Checkbox Prompt ---
+class CheckboxPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.selectedIndex = 0;
+        this.errorMsg = '';
+        this.checkedState = options.choices.map(c => !!c.selected);
+    }
+    render(firstRender) {
+        // Ensure cursor is HIDDEN for menus
+        this.print(ansi_1.ANSI.HIDE_CURSOR);
+        if (!firstRender) {
+            const extraLines = this.errorMsg ? 1 : 0;
+            this.print(`\x1b[${this.options.choices.length + 1 + extraLines}A`);
+        }
+        this.print(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}`);
+        const icon = this.errorMsg ? `${theme_1.theme.error}✖` : `${theme_1.theme.success}?`;
+        this.print(`${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${theme_1.theme.muted}(Press <space> to select, <enter> to confirm)${ansi_1.ANSI.RESET}\n`);
+        this.options.choices.forEach((choice, index) => {
+            this.print(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}`);
+            const cursor = index === this.selectedIndex ? `${theme_1.theme.main}❯${ansi_1.ANSI.RESET}` : ' ';
+            const isChecked = this.checkedState[index];
+            const checkbox = isChecked
+                ? `${theme_1.theme.success}◉${ansi_1.ANSI.RESET}`
+                : `${theme_1.theme.muted}◯${ansi_1.ANSI.RESET}`;
+            const title = index === this.selectedIndex
+                ? `${theme_1.theme.main}${choice.title}${ansi_1.ANSI.RESET}`
+                : choice.title;
+            this.print(`${cursor} ${checkbox} ${title}\n`);
+        });
+        if (this.errorMsg) {
+            this.print(`${ansi_1.ANSI.ERASE_LINE}${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`);
+        }
+        else if (!firstRender) {
+            this.print(`${ansi_1.ANSI.ERASE_LINE}`);
+        }
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            const selectedCount = this.checkedState.filter(Boolean).length;
+            const { min = 0, max } = this.options;
+            if (selectedCount < min) {
+                this.errorMsg = `You must select at least ${min} options.`;
+                this.render(false);
+                return;
+            }
+            if (max && selectedCount > max) {
+                this.errorMsg = `You can only select up to ${max} options.`;
+                this.render(false);
+                return;
+            }
+            this.cleanup();
+            this.print(ansi_1.ANSI.SHOW_CURSOR + '\n');
+            const results = this.options.choices
+                .filter((_, i) => this.checkedState[i])
+                .map(c => c.value);
+            if (this._resolve)
+                this._resolve(results);
+            return;
+        }
+        if (char === ' ') {
+            const currentChecked = this.checkedState[this.selectedIndex];
+            const selectedCount = this.checkedState.filter(Boolean).length;
+            const { max } = this.options;
+            if (!currentChecked && max && selectedCount >= max) {
+                this.errorMsg = `Max ${max} selections allowed.`;
+            }
+            else {
+                this.checkedState[this.selectedIndex] = !currentChecked;
+                this.errorMsg = '';
+            }
+            this.render(false);
+        }
+        if (this.isUp(char)) { // Up
+            this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.options.choices.length - 1;
+            this.errorMsg = '';
+            this.render(false);
+        }
+        if (this.isDown(char)) { // Down
+            this.selectedIndex = this.selectedIndex < this.options.choices.length - 1 ? this.selectedIndex + 1 : 0;
+            this.errorMsg = '';
+            this.render(false);
+        }
+    }
+}
+exports.CheckboxPrompt = CheckboxPrompt;

package/dist/prompts/confirm.d.ts

@@ -0,0 +1,7 @@
+import { Prompt } from '../base';
+import { ConfirmOptions } from '../types';
+export declare class ConfirmPrompt extends Prompt<boolean, ConfirmOptions> {
+    constructor(options: ConfirmOptions);
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}

package/dist/prompts/confirm.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfirmPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+// --- Implementation: Confirm Prompt ---
+class ConfirmPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.value = options.initial ?? true;
+    }
+    render(firstRender) {
+        // Hide cursor for confirm, user just hits Y/N or Enter
+        this.print(ansi_1.ANSI.HIDE_CURSOR);
+        if (!firstRender) {
+            this.print(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}`);
+        }
+        const hint = this.value ? `${ansi_1.ANSI.BOLD}Yes${ansi_1.ANSI.RESET}/no` : `yes/${ansi_1.ANSI.BOLD}No${ansi_1.ANSI.RESET}`;
+        this.print(`${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}(${hint})${ansi_1.ANSI.RESET} `);
+        const text = this.value ? 'Yes' : 'No';
+        this.print(`${theme_1.theme.main}${text}${ansi_1.ANSI.RESET}\x1b[${text.length}D`);
+    }
+    handleInput(char) {
+        const c = char.toLowerCase();
+        if (c === '\r' || c === '\n') {
+            this.submit(this.value);
+            return;
+        }
+        if (c === 'y') {
+            this.value = true;
+            this.render(false);
+        }
+        if (c === 'n') {
+            this.value = false;
+            this.render(false);
+        }
+    }
+}
+exports.ConfirmPrompt = ConfirmPrompt;

package/dist/prompts/date.d.ts

@@ -0,0 +1,10 @@
+import { Prompt } from '../base';
+import { DateOptions } from '../types';
+export declare class DatePrompt extends Prompt<Date, DateOptions> {
+    private selectedField;
+    private errorMsg;
+    private inputBuffer;
+    constructor(options: DateOptions);
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}

package/dist/prompts/date.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatePrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+// --- Implementation: Date Prompt ---
+class DatePrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.selectedField = 0; // 0: Year, 1: Month, 2: Day, 3: Hour, 4: Minute
+        this.errorMsg = '';
+        this.inputBuffer = '';
+        this.value = options.initial || new Date();
+    }
+    render(firstRender) {
+        this.print(ansi_1.ANSI.HIDE_CURSOR);
+        if (!firstRender) {
+            this.print(ansi_1.ANSI.ERASE_LINE + ansi_1.ANSI.CURSOR_LEFT);
+            if (this.errorMsg) {
+                this.print(ansi_1.ANSI.UP + ansi_1.ANSI.ERASE_LINE + ansi_1.ANSI.CURSOR_LEFT);
+            }
+        }
+        const y = this.value.getFullYear();
+        const m = (this.value.getMonth() + 1).toString().padStart(2, '0');
+        const d = this.value.getDate().toString().padStart(2, '0');
+        const h = this.value.getHours().toString().padStart(2, '0');
+        const min = this.value.getMinutes().toString().padStart(2, '0');
+        const fields = [y, m, d, h, min];
+        const display = fields.map((val, i) => {
+            if (i === this.selectedField)
+                return `${theme_1.theme.main}${ansi_1.ANSI.UNDERLINE}${val}${ansi_1.ANSI.RESET}`;
+            return val;
+        });
+        const icon = this.errorMsg ? `${theme_1.theme.error}✖` : `${theme_1.theme.success}?`;
+        const dateStr = `${display[0]}-${display[1]}-${display[2]} ${display[3]}:${display[4]}`;
+        this.print(`${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${dateStr} ${theme_1.theme.muted}(Use arrows or type)${ansi_1.ANSI.RESET}`);
+        if (this.errorMsg) {
+            this.print(`\n${ansi_1.ANSI.ERASE_LINE}${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`);
+            this.print(ansi_1.ANSI.UP);
+            // restore cursor pos logic isn't needed as we are on one line mostly, but for consistency:
+            const promptLen = this.options.message.length + 3; // roughly
+            this.print(`\x1b[1000D\x1b[${promptLen + 15}C`); // approx move back
+        }
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            this.submit(this.value);
+            return;
+        }
+        if (this.isLeft(char)) { // Left
+            this.selectedField = Math.max(0, this.selectedField - 1);
+            this.inputBuffer = ''; // Reset buffer on move
+            this.errorMsg = '';
+            this.render(false);
+            return;
+        }
+        if (this.isRight(char)) { // Right
+            this.selectedField = Math.min(4, this.selectedField + 1);
+            this.inputBuffer = ''; // Reset buffer on move
+            this.errorMsg = '';
+            this.render(false);
+            return;
+        }
+        // Support numeric input
+        if (/^\d$/.test(char)) {
+            const maxLen = this.selectedField === 0 ? 4 : 2;
+            let nextBuffer = this.inputBuffer + char;
+            // If we exceed max length, reset to just the new char (assuming user is starting a new number)
+            // Or better: try to parse.
+            // Logic: 
+            // 1. Try appending.
+            // 2. Validate.
+            // 3. If valid, keep.
+            // 4. If invalid (e.g. Month 13), assume new start -> set buffer to just char.
+            // However, we must respect field limits first.
+            if (nextBuffer.length > maxLen) {
+                nextBuffer = char;
+            }
+            const val = parseInt(nextBuffer, 10);
+            let valid = true;
+            // Pre-validation to decide if we should append or reset
+            if (this.selectedField === 1 && (val < 1 || val > 12))
+                valid = false; // Month
+            if (this.selectedField === 2 && (val < 1 || val > 31))
+                valid = false; // Day (rough check)
+            if (this.selectedField === 3 && (val > 23))
+                valid = false; // Hour
+            if (this.selectedField === 4 && (val > 59))
+                valid = false; // Minute
+            if (!valid) {
+                // If appending made it invalid (e.g. was '1', typed '3' -> '13' invalid month),
+                // treat '3' as the start of a new number.
+                nextBuffer = char;
+            }
+            this.inputBuffer = nextBuffer;
+            const finalVal = parseInt(this.inputBuffer, 10);
+            const d = new Date(this.value);
+            if (this.selectedField === 0) {
+                // Year is special, we just set it. 
+                d.setFullYear(finalVal);
+            }
+            else if (this.selectedField === 1)
+                d.setMonth(Math.max(0, Math.min(11, finalVal - 1)));
+            else if (this.selectedField === 2)
+                d.setDate(Math.max(1, Math.min(31, finalVal)));
+            else if (this.selectedField === 3)
+                d.setHours(Math.max(0, Math.min(23, finalVal)));
+            else if (this.selectedField === 4)
+                d.setMinutes(Math.max(0, Math.min(59, finalVal)));
+            this.value = d;
+            this.errorMsg = '';
+            this.render(false);
+            return;
+        }
+        // Support standard and application cursor keys
+        const isUp = this.isUp(char);
+        const isDown = this.isDown(char);
+        if (isUp || isDown) {
+            this.inputBuffer = ''; // Reset buffer on arrow move
+            const dir = isUp ? 1 : -1;
+            const d = new Date(this.value);
+            switch (this.selectedField) {
+                case 0:
+                    d.setFullYear(d.getFullYear() + dir);
+                    break;
+                case 1:
+                    d.setMonth(d.getMonth() + dir);
+                    break;
+                case 2:
+                    d.setDate(d.getDate() + dir);
+                    break;
+                case 3:
+                    d.setHours(d.getHours() + dir);
+                    break;
+                case 4:
+                    d.setMinutes(d.getMinutes() + dir);
+                    break;
+            }
+            let valid = true;
+            if (this.options.min && d < this.options.min) {
+                this.errorMsg = 'Date cannot be before minimum allowed.';
+                valid = false;
+            }
+            if (this.options.max && d > this.options.max) {
+                this.errorMsg = 'Date cannot be after maximum allowed.';
+                valid = false;
+            }
+            if (valid) {
+                this.value = d;
+                this.errorMsg = '';
+            }
+            this.render(false);
+        }
+    }
+}
+exports.DatePrompt = DatePrompt;

package/dist/prompts/file.d.ts

@@ -0,0 +1,13 @@
+import { Prompt } from '../base';
+import { FileOptions } from '../types';
+export declare class FilePrompt extends Prompt<string, FileOptions> {
+    private input;
+    private cursor;
+    private suggestions;
+    private selectedSuggestion;
+    private errorMsg;
+    constructor(options: FileOptions);
+    private updateSuggestions;
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}

package/dist/prompts/file.js

@@ -0,0 +1,194 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilePrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// --- Implementation: File Prompt ---
+class FilePrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.input = '';
+        this.cursor = 0;
+        this.suggestions = [];
+        this.selectedSuggestion = -1;
+        this.errorMsg = '';
+        this.input = options.basePath || '';
+        this.cursor = this.input.length;
+    }
+    updateSuggestions() {
+        try {
+            const dir = path.dirname(this.input) || '.';
+            const partial = path.basename(this.input);
+            if (fs.existsSync(dir) && fs.statSync(dir).isDirectory()) {
+                const files = fs.readdirSync(dir);
+                this.suggestions = files
+                    .filter(f => f.startsWith(partial))
+                    .filter(f => {
+                    const fullPath = path.join(dir, f);
+                    const isDir = fs.statSync(fullPath).isDirectory();
+                    if (this.options.onlyDirectories && !isDir)
+                        return false;
+                    if (this.options.extensions && !isDir) {
+                        return this.options.extensions.some(ext => f.endsWith(ext));
+                    }
+                    return true;
+                })
+                    .map(f => {
+                    const fullPath = path.join(dir, f);
+                    if (fs.statSync(fullPath).isDirectory())
+                        return f + '/';
+                    return f;
+                });
+            }
+            else {
+                this.suggestions = [];
+            }
+        }
+        catch (e) {
+            this.suggestions = [];
+        }
+        this.selectedSuggestion = -1;
+    }
+    render(firstRender) {
+        this.print(ansi_1.ANSI.SHOW_CURSOR);
+        if (!firstRender) {
+            // Clear input line + suggestions
+            this.print(ansi_1.ANSI.ERASE_LINE + ansi_1.ANSI.CURSOR_LEFT); // Input line
+            // We need to track how many lines suggestions took
+            // For now assume simple clear, or use ANSI.ERASE_DOWN if at bottom?
+            // Safer to move up and clear
+            this.print(ansi_1.ANSI.ERASE_DOWN);
+        }
+        const icon = this.errorMsg ? `${theme_1.theme.error}✖` : `${theme_1.theme.success}?`;
+        this.print(`${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${this.input}`);
+        if (this.suggestions.length > 0) {
+            this.print('\n');
+            const maxShow = 5;
+            this.suggestions.slice(0, maxShow).forEach((s, i) => {
+                if (i === this.selectedSuggestion) {
+                    this.print(`${theme_1.theme.main}❯ ${s}${ansi_1.ANSI.RESET}\n`);
+                }
+                else {
+                    this.print(`  ${s}\n`);
+                }
+            });
+            if (this.suggestions.length > maxShow) {
+                this.print(`  ...and ${this.suggestions.length - maxShow} more\n`);
+            }
+            // Move cursor back to input line
+            const lines = Math.min(this.suggestions.length, maxShow) + (this.suggestions.length > maxShow ? 2 : 1);
+            this.print(`\x1b[${lines}A`);
+            const inputLen = this.options.message.length + 3 + this.input.length;
+            this.print(`\x1b[${inputLen}C`);
+        }
+    }
+    handleInput(char) {
+        if (char === '\t') { // Tab
+            if (this.suggestions.length === 1) {
+                const dir = path.dirname(this.input);
+                this.input = path.join(dir === '.' ? '' : dir, this.suggestions[0]);
+                this.cursor = this.input.length;
+                this.suggestions = [];
+                this.render(false);
+            }
+            else if (this.suggestions.length > 1) {
+                // Cycle or show? For now cycle if selected
+                if (this.selectedSuggestion !== -1) {
+                    const dir = path.dirname(this.input);
+                    this.input = path.join(dir === '.' ? '' : dir, this.suggestions[this.selectedSuggestion]);
+                    this.cursor = this.input.length;
+                    this.suggestions = [];
+                    this.render(false);
+                }
+                else {
+                    // Just show suggestions (already done in render loop usually, but update logic ensures it)
+                    this.updateSuggestions();
+                    this.render(false);
+                }
+            }
+            else {
+                this.updateSuggestions();
+                this.render(false);
+            }
+            return;
+        }
+        if (char === '\r' || char === '\n') {
+            if (this.selectedSuggestion !== -1) {
+                const dir = path.dirname(this.input);
+                this.input = path.join(dir === '.' ? '' : dir, this.suggestions[this.selectedSuggestion]);
+                this.cursor = this.input.length;
+                this.suggestions = [];
+                this.selectedSuggestion = -1;
+                this.render(false);
+            }
+            else {
+                this.submit(this.input);
+            }
+            return;
+        }
+        if (this.isDown(char)) { // Down
+            if (this.suggestions.length > 0) {
+                this.selectedSuggestion = (this.selectedSuggestion + 1) % Math.min(this.suggestions.length, 5);
+                this.render(false);
+            }
+            return;
+        }
+        if (this.isUp(char)) { // Up
+            if (this.suggestions.length > 0) {
+                this.selectedSuggestion = (this.selectedSuggestion - 1 + Math.min(this.suggestions.length, 5)) % Math.min(this.suggestions.length, 5);
+                this.render(false);
+            }
+            return;
+        }
+        if (char === '\u0008' || char === '\x7f') { // Backspace
+            if (this.input.length > 0) {
+                this.input = this.input.slice(0, -1);
+                this.updateSuggestions();
+                this.render(false);
+            }
+            return;
+        }
+        if (!/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            this.input += char;
+            this.updateSuggestions();
+            this.render(false);
+        }
+    }
+}
+exports.FilePrompt = FilePrompt;

package/dist/prompts/list.d.ts

@@ -0,0 +1,9 @@
+import { Prompt } from '../base';
+import { ListOptions } from '../types';
+export declare class ListPrompt extends Prompt<string[], ListOptions> {
+    private currentInput;
+    private errorMsg;
+    constructor(options: ListOptions);
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}

package/dist/prompts/list.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+// --- Implementation: List Prompt ---
+class ListPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.currentInput = '';
+        this.errorMsg = '';
+        this.value = options.initial || [];
+    }
+    render(firstRender) {
+        this.print(ansi_1.ANSI.SHOW_CURSOR);
+        if (!firstRender) {
+            this.print(ansi_1.ANSI.ERASE_LINE + ansi_1.ANSI.CURSOR_LEFT);
+            if (this.errorMsg) {
+                this.print(ansi_1.ANSI.UP + ansi_1.ANSI.ERASE_LINE + ansi_1.ANSI.CURSOR_LEFT);
+            }
+        }
+        const icon = this.errorMsg ? `${theme_1.theme.error}✖` : `${theme_1.theme.success}?`;
+        this.print(`${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} `);
+        // Render Tags
+        if (this.value.length > 0) {
+            this.value.forEach((tag) => {
+                this.print(`${theme_1.theme.main}[${tag}]${ansi_1.ANSI.RESET} `);
+            });
+        }
+        // Render Current Input
+        this.print(`${this.currentInput}`);
+        if (this.errorMsg) {
+            this.print(`\n${ansi_1.ANSI.ERASE_LINE}${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`);
+            this.print(ansi_1.ANSI.UP);
+            // Return cursor
+            const promptLen = this.options.message.length + 3;
+            let tagsLen = 0;
+            this.value.forEach((tag) => tagsLen += tag.length + 3); // [tag] + space
+            const inputLen = this.currentInput.length;
+            this.print(`\x1b[1000D\x1b[${promptLen + tagsLen + inputLen}C`);
+        }
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            if (this.currentInput.trim()) {
+                this.value.push(this.currentInput.trim());
+                this.currentInput = '';
+                this.errorMsg = '';
+                this.render(false);
+            }
+            else {
+                // Done if input is empty
+                if (this.options.validate) {
+                    const result = this.options.validate(this.value);
+                    if (result !== true) {
+                        this.errorMsg = typeof result === 'string' ? result : 'Invalid input';
+                        this.render(false);
+                        return;
+                    }
+                }
+                this.submit(this.value);
+            }
+            return;
+        }
+        if (char === '\u0008' || char === '\x7f') { // Backspace
+            if (this.currentInput.length > 0) {
+                this.currentInput = this.currentInput.slice(0, -1);
+                this.render(false);
+            }
+            else if (this.value.length > 0) {
+                this.value.pop();
+                this.render(false);
+            }
+            return;
+        }
+        if (!/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            this.currentInput += char;
+            this.render(false);
+        }
+    }
+}
+exports.ListPrompt = ListPrompt;

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

@@ -0,0 +1,14 @@
+import { Prompt } from '../base';
+import { MultiSelectOptions } from '../types';
+export declare class MultiSelectPrompt extends Prompt<any[], MultiSelectOptions> {
+    private selectedIndex;
+    private checkedState;
+    private searchBuffer;
+    private scrollTop;
+    private readonly pageSize;
+    private errorMsg;
+    constructor(options: MultiSelectOptions);
+    private getFilteredChoices;
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}