mepcli 0.5.5 → 0.6.0

package/dist/prompts/form.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormPrompt = 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 FormPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.values = {};
+        this.activeIndex = 0;
+        this.fieldErrors = {};
+        this.globalError = '';
+        this.cursor = 0; // Cursor position for the ACTIVE field.
+        this.lastLinesUp = 0; // To track cursor position after render
+        this.options.fields.forEach(field => {
+            this.values[field.name] = field.initial || '';
+        });
+        this.cursor = this.values[this.options.fields[0].name].length;
+    }
+    render(firstRender) {
+        if (!firstRender && this.lastLinesUp > 0) {
+            this.print(`\x1b[${this.lastLinesUp}B`);
+        }
+        this.lastLinesUp = 0;
+        const outputLines = [];
+        // Title
+        outputLines.push(`${theme_1.theme.success}? ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}`);
+        if (this.globalError) {
+            outputLines.push(`${theme_1.theme.error}>> ${this.globalError}${ansi_1.ANSI.RESET}`);
+        }
+        let cursorLineIndex = -1;
+        let cursorColIndex = 0;
+        this.options.fields.forEach((field, index) => {
+            const isActive = index === this.activeIndex;
+            const value = this.values[field.name];
+            const error = this.fieldErrors[field.name];
+            // Icon
+            let icon = '';
+            if (isActive) {
+                icon = `${theme_1.theme.main}${symbols_1.symbols.pointer}`; // >
+            }
+            else {
+                icon = ' '; // indent
+            }
+            // Label
+            const labelStyle = isActive ? `${theme_1.theme.main}${ansi_1.ANSI.BOLD}` : theme_1.theme.muted;
+            const label = `${labelStyle}${field.message}:${ansi_1.ANSI.RESET}`;
+            // Value
+            // Note: Use Secret/Password prompt for case sensitive input, Form prompt is for general text input
+            const displayValue = isActive ? value : `${theme_1.theme.muted}${value}${ansi_1.ANSI.RESET}`;
+            // Construct Line
+            const line = `${icon} ${label} ${displayValue}`;
+            outputLines.push(line);
+            if (isActive) {
+                // Determine cursor position
+                // We need visual length of "icon + label + value_up_to_cursor"
+                const prefix = `${icon} ${label} `;
+                const valuePrefix = value.substring(0, this.cursor);
+                cursorLineIndex = outputLines.length - 1;
+                cursorColIndex = (0, utils_1.stringWidth)(this.stripAnsi(prefix)) + (0, utils_1.stringWidth)(this.stripAnsi(valuePrefix));
+            }
+            // Error for this field
+            if (error) {
+                outputLines.push(`  ${theme_1.theme.error}>> ${error}${ansi_1.ANSI.RESET}`);
+            }
+        });
+        // Instructions
+        outputLines.push('');
+        outputLines.push(`${ansi_1.ANSI.RESET}${theme_1.theme.muted}(Use Up/Down/Tab to navigate, Enter to submit)${ansi_1.ANSI.RESET}`);
+        const output = outputLines.join('\n');
+        this.renderFrame(output);
+        // Position Cursor
+        this.print(ansi_1.ANSI.SHOW_CURSOR);
+        if (cursorLineIndex !== -1) {
+            // Calculate lines up from bottom
+            const totalLines = outputLines.length;
+            const linesUp = (totalLines - 1) - cursorLineIndex;
+            if (linesUp > 0) {
+                this.print(`\x1b[${linesUp}A`);
+                this.lastLinesUp = linesUp;
+            }
+            this.print(ansi_1.ANSI.CURSOR_LEFT);
+            if (cursorColIndex > 0) {
+                this.print(`\x1b[${cursorColIndex}C`);
+            }
+        }
+    }
+    handleInput(char, key) {
+        // Navigation: Up / Shift+Tab
+        if (this.isUp(char) || (char === '\t' && key /* how to detect Shift+Tab? usually \u001b[Z */) || char === '\u001b[Z') {
+            this.validateCurrentField();
+            this.moveFocus(-1);
+            return;
+        }
+        // Navigation: Down / Tab
+        if (this.isDown(char) || char === '\t') {
+            this.validateCurrentField();
+            this.moveFocus(1);
+            return;
+        }
+        // Enter
+        if (char === '\r' || char === '\n') {
+            this.validateCurrentField().then(isValid => {
+                if (isValid) {
+                    if (this.activeIndex < this.options.fields.length - 1) {
+                        this.moveFocus(1);
+                    }
+                    else {
+                        // Submit
+                        this.submitForm();
+                    }
+                }
+            });
+            return;
+        }
+        // Editing Active Field
+        const activeField = this.options.fields[this.activeIndex];
+        const val = this.values[activeField.name];
+        if (char === '\u0008' || char === '\x7f') { // Backspace
+            if (this.cursor > 0) {
+                const pre = val.slice(0, this.cursor - 1);
+                const post = val.slice(this.cursor);
+                this.values[activeField.name] = pre + post;
+                this.cursor--;
+                this.render(false);
+            }
+            return;
+        }
+        // Left/Right arrow to move cursor within field
+        if (this.isLeft(char)) {
+            if (this.cursor > 0)
+                this.cursor--;
+            this.render(false);
+            return;
+        }
+        if (this.isRight(char)) {
+            if (this.cursor < val.length)
+                this.cursor++;
+            this.render(false);
+            return;
+        }
+        // Typing
+        if (!/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            const pre = val.slice(0, this.cursor);
+            const post = val.slice(this.cursor);
+            this.values[activeField.name] = pre + char + post;
+            this.cursor += char.length;
+            this.fieldErrors[activeField.name] = ''; // Clear error on type
+            this.render(false);
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.validateCurrentField();
+                this.moveFocus(-1);
+            }
+            else if (event.scroll === 'down') {
+                this.validateCurrentField();
+                this.moveFocus(1);
+            }
+        }
+    }
+    moveFocus(direction) {
+        const nextIndex = this.activeIndex + direction;
+        if (nextIndex >= 0 && nextIndex < this.options.fields.length) {
+            this.activeIndex = nextIndex;
+            // "cursor must jump to end of data"
+            this.cursor = this.values[this.options.fields[this.activeIndex].name].length;
+            this.render(false);
+        }
+    }
+    async validateCurrentField() {
+        const field = this.options.fields[this.activeIndex];
+        const val = this.values[field.name];
+        if (field.validate) {
+            try {
+                const res = await field.validate(val);
+                if (res !== true) {
+                    this.fieldErrors[field.name] = typeof res === 'string' ? res : 'Invalid value';
+                    this.render(false);
+                    return false;
+                }
+            }
+            catch (err) {
+                this.fieldErrors[field.name] = err.message || 'Validation failed';
+                this.render(false);
+                return false;
+            }
+        }
+        // Clear error if valid
+        delete this.fieldErrors[field.name];
+        this.render(false);
+        return true;
+    }
+    async submitForm() {
+        this.globalError = '';
+        // Validate all fields
+        let allValid = true;
+        for (const field of this.options.fields) {
+            const val = this.values[field.name];
+            if (field.validate) {
+                const res = await field.validate(val);
+                if (res !== true) {
+                    this.fieldErrors[field.name] = typeof res === 'string' ? res : 'Invalid value';
+                    allValid = false;
+                }
+                else {
+                    delete this.fieldErrors[field.name];
+                }
+            }
+        }
+        if (allValid) {
+            this.submit(this.values);
+        }
+        else {
+            this.globalError = 'Please fix errors before submitting.';
+            this.render(false);
+        }
+    }
+}
+exports.FormPrompt = FormPrompt;

package/dist/prompts/grid.d.ts

@@ -0,0 +1,14 @@
+import { Prompt } from '../base';
+import { GridOptions, MouseEvent } from '../types';
+export declare class GridPrompt extends Prompt<boolean[][], GridOptions> {
+    private cursorRow;
+    private cursorCol;
+    private selected;
+    private columnWidths;
+    private rowLabelWidth;
+    constructor(options: GridOptions);
+    private calculateLayout;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string, _key: Buffer): void;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/grid.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const utils_1 = require("../utils");
+class GridPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.cursorRow = 0;
+        this.cursorCol = 0;
+        this.columnWidths = [];
+        this.rowLabelWidth = 0;
+        // Initialize selection matrix
+        if (options.initial) {
+            this.selected = options.initial.map(row => [...row]);
+        }
+        else {
+            this.selected = options.rows.map(() => new Array(options.columns.length).fill(false));
+        }
+        this.calculateLayout();
+    }
+    calculateLayout() {
+        // Calculate max width for row labels
+        this.rowLabelWidth = 0;
+        for (const row of this.options.rows) {
+            this.rowLabelWidth = Math.max(this.rowLabelWidth, (0, utils_1.stringWidth)(row));
+        }
+        // Calculate width for each column
+        this.columnWidths = this.options.columns.map(col => {
+            // Header width vs Cell width (3 chars for "[ ]")
+            return Math.max((0, utils_1.stringWidth)(col), 3);
+        });
+    }
+    render(_firstRender) {
+        const { rows, columns } = this.options;
+        let output = `${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        // Render Header
+        // Padding for the row label column
+        output += ' '.repeat(this.rowLabelWidth + 2); // +2 for spacing/border
+        output += columns.map((col, i) => {
+            const width = this.columnWidths[i];
+            const padding = width - (0, utils_1.stringWidth)(col);
+            const leftPad = Math.floor(padding / 2);
+            const rightPad = padding - leftPad;
+            return `${theme_1.theme.muted}${' '.repeat(leftPad)}${col}${' '.repeat(rightPad)}${ansi_1.ANSI.RESET}`;
+        }).join('  ') + '\n';
+        // Render Rows
+        for (let r = 0; r < rows.length; r++) {
+            const rowLabel = rows[r];
+            const labelPadding = this.rowLabelWidth - (0, utils_1.stringWidth)(rowLabel);
+            // Row Label
+            output += `${theme_1.theme.muted}${rowLabel}${' '.repeat(labelPadding)}${ansi_1.ANSI.RESET}  `;
+            // Cells
+            const cells = this.selected[r].map((isChecked, c) => {
+                const isFocused = (r === this.cursorRow && c === this.cursorCol);
+                const width = this.columnWidths[c];
+                const content = isChecked ? `[${theme_1.theme.success}x${ansi_1.ANSI.RESET}]` : '[ ]';
+                // content string width is 3 (ignoring ansi)
+                const padding = width - 3;
+                const leftPad = Math.floor(padding / 2);
+                const rightPad = padding - leftPad;
+                let cellStr = `${' '.repeat(leftPad)}${content}${' '.repeat(rightPad)}`;
+                if (isFocused) {
+                    // Highlight the focused cell
+                    // If we use ANSI.REVERSE on the whole cell including padding:
+                    cellStr = `${ansi_1.ANSI.REVERSE}${cellStr}${ansi_1.ANSI.RESET}`;
+                }
+                return cellStr;
+            });
+            output += cells.join('  ') + '\n';
+        }
+        output += `${theme_1.theme.muted}Arrows to move, Space to toggle, Enter to submit${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+    handleInput(char, _key) {
+        const isUp = this.isUp(char);
+        const isDown = this.isDown(char);
+        const isLeft = this.isLeft(char);
+        const isRight = this.isRight(char);
+        if (isUp || isDown || isLeft || isRight) {
+            if (isUp)
+                this.cursorRow = Math.max(0, this.cursorRow - 1);
+            if (isDown)
+                this.cursorRow = Math.min(this.options.rows.length - 1, this.cursorRow + 1);
+            if (isLeft)
+                this.cursorCol = Math.max(0, this.cursorCol - 1);
+            if (isRight)
+                this.cursorCol = Math.min(this.options.columns.length - 1, this.cursorCol + 1);
+            this.render(false);
+            return;
+        }
+        if (char === ' ') {
+            this.selected[this.cursorRow][this.cursorCol] = !this.selected[this.cursorRow][this.cursorCol];
+            this.render(false);
+            return;
+        }
+        if (char === '\r' || char === '\n') {
+            this.submit(this.selected);
+            return;
+        }
+        // PageUp (First Row)
+        if (char === '\x1b[5~') {
+            this.cursorRow = 0;
+            this.render(false);
+            return;
+        }
+        // PageDown (Last Row)
+        if (char === '\x1b[6~') {
+            this.cursorRow = this.options.rows.length - 1;
+            this.render(false);
+            return;
+        }
+        // Home (First Column)
+        if (char === '\x1b[H' || char === '\x1b[1~') {
+            this.cursorCol = 0;
+            this.render(false);
+            return;
+        }
+        // End (Last Column)
+        if (char === '\x1b[F' || char === '\x1b[4~') {
+            this.cursorCol = this.options.columns.length - 1;
+            this.render(false);
+            return;
+        }
+        // r: Toggle Row
+        if (char === 'r') {
+            const row = this.selected[this.cursorRow];
+            const allSelected = row.every(c => c);
+            this.selected[this.cursorRow] = row.map(() => !allSelected);
+            this.render(false);
+            return;
+        }
+        // c: Toggle Column
+        if (char === 'c') {
+            const colIdx = this.cursorCol;
+            const colValues = this.selected.map(row => row[colIdx]);
+            const allSelected = colValues.every(c => c);
+            this.selected.forEach(row => row[colIdx] = !allSelected);
+            this.render(false);
+            return;
+        }
+        // a: Select All
+        if (char === 'a') {
+            this.selected = this.selected.map(row => row.map(() => true));
+            this.render(false);
+            return;
+        }
+        // x: Deselect All
+        if (char === 'x') {
+            this.selected = this.selected.map(row => row.map(() => false));
+            this.render(false);
+            return;
+        }
+        // i: Invert
+        if (char === 'i') {
+            this.selected = this.selected.map(row => row.map(v => !v));
+            this.render(false);
+            return;
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            const direction = event.scroll === 'up' ? -1 : 1;
+            if (event.shift) {
+                // Horizontal (Column)
+                this.cursorCol = Math.max(0, Math.min(this.options.columns.length - 1, this.cursorCol + direction));
+            }
+            else {
+                // Vertical (Row)
+                this.cursorRow = Math.max(0, Math.min(this.options.rows.length - 1, this.cursorRow + direction));
+            }
+            this.render(false);
+        }
+    }
+}
+exports.GridPrompt = GridPrompt;

package/dist/prompts/keypress.d.ts

@@ -2,6 +2,6 @@ import { Prompt } from '../base';
 import { KeypressOptions } from '../types';
 export declare class KeypressPrompt extends Prompt<string, KeypressOptions> {
     constructor(options: KeypressOptions);
-    protected render(firstRender: boolean): void;
-    protected handleInput(char: string, key: Buffer): void;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string, _key: Buffer): void;
 }

package/dist/prompts/keypress.js

@@ -8,7 +8,7 @@ class KeypressPrompt extends base_1.Prompt {
     constructor(options) {
         super(options);
     }
-    render(firstRender) {
+    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 => {
@@ -27,7 +27,7 @@ class KeypressPrompt extends base_1.Prompt {
         }
         this.renderFrame(output);
     }
-    handleInput(char, key) {
+    handleInput(char, _key) {
         let keyName = char;
         if (char === '\r' || char === '\n')
             keyName = 'enter';

package/dist/prompts/list.d.ts

@@ -4,6 +4,6 @@ export declare class ListPrompt extends Prompt<string[], ListOptions> {
     private currentInput;
     private errorMsg;
     constructor(options: ListOptions);
-    protected render(firstRender: boolean): void;
+    protected render(_firstRender: boolean): void;
     protected handleInput(char: string): void;
 }

package/dist/prompts/list.js

@@ -13,38 +13,57 @@ class ListPrompt extends base_1.Prompt {
         this.errorMsg = '';
         this.value = options.initial || [];
     }
-    render(firstRender) {
-        // Prepare content
+    render(_firstRender) {
+        const cols = process.stdout.columns || 80;
+        // 1. Prepare Prefix
         const icon = this.errorMsg ? `${theme_1.theme.error}${symbols_1.symbols.cross}` : `${theme_1.theme.success}?`;
-        let mainLine = `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} `;
+        const prefix = `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} `;
+        // 2. Build Lines with Wrapping
+        const lines = [];
+        let currentLine = prefix;
+        // Helper to check width
+        const addText = (text) => {
+            const visualLen = this.stripAnsi(currentLine).length + this.stripAnsi(text).length;
+            if (visualLen > cols) {
+                lines.push(currentLine);
+                currentLine = text.trimStart(); // Start new line
+            }
+            else {
+                currentLine += text;
+            }
+        };
         // Render Tags
         if (this.value.length > 0) {
             this.value.forEach((tag) => {
-                mainLine += `${theme_1.theme.main}[${tag}]${ansi_1.ANSI.RESET} `;
+                const tagStr = `${theme_1.theme.main}[${tag}]${ansi_1.ANSI.RESET} `;
+                addText(tagStr);
             });
         }
         // Render Current Input
-        mainLine += `${this.currentInput}`;
-        let output = mainLine;
+        addText(this.currentInput);
+        lines.push(currentLine); // Push the last line
+        // Track where the input ends (for cursor positioning)
+        const inputLineIndex = lines.length - 1;
+        const inputVisualCol = this.stripAnsi(currentLine).length;
+        // 3. Append Error if any
         if (this.errorMsg) {
-            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
+            lines.push(`${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`);
         }
-        // Use Double Buffering
+        const output = lines.join('\n');
+        // 4. Render Frame
         this.renderFrame(output);
         this.print(ansi_1.ANSI.SHOW_CURSOR);
-        // If we printed an error, the cursor is at the end of the error line.
-        // We need to move it back to the end of the input line.
-        if (this.errorMsg) {
-            // Move up one line (since error is always on the next line in this simple implementation)
-            this.print(ansi_1.ANSI.UP);
-            // Move to the correct column.
-            // We need to calculate visual length of mainLine to place cursor correctly.
-            // stripAnsi is available in base class now.
-            const visualLength = this.stripAnsi(mainLine).length;
-            this.print(ansi_1.ANSI.CURSOR_LEFT); // Go to start
-            if (visualLength > 0) {
-                this.print(`\x1b[${visualLength}C`);
-            }
+        // 5. Position Cursor
+        // If we printed lines after the input line (e.g. error msg), move up.
+        const totalRows = lines.length;
+        const linesUp = (totalRows - 1) - inputLineIndex;
+        if (linesUp > 0) {
+            this.print(`\x1b[${linesUp}A`);
+        }
+        // Move to correct column
+        this.print(ansi_1.ANSI.CURSOR_LEFT);
+        if (inputVisualCol > 0) {
+            this.print(`\x1b[${inputVisualCol}C`);
         }
     }
     handleInput(char) {
@@ -75,7 +94,8 @@ class ListPrompt extends base_1.Prompt {
                 this.render(false);
             }
             else if (this.value.length > 0) {
-                this.value.pop();
+                const last = this.value.pop();
+                this.currentInput = last || '';
                 this.render(false);
             }
             return;

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

@@ -9,7 +9,7 @@ export declare class MultiSelectPrompt<V> extends Prompt<any[], MultiSelectOptio
     private errorMsg;
     constructor(options: MultiSelectOptions<V>);
     private getFilteredChoices;
-    protected render(firstRender: boolean): void;
+    protected render(_firstRender: boolean): void;
     protected handleInput(char: string): void;
     protected handleMouse(event: MouseEvent): void;
 }

package/dist/prompts/multi-select.js

@@ -24,7 +24,7 @@ class MultiSelectPrompt extends base_1.Prompt {
             .map((c, i) => ({ ...c, originalIndex: i }))
             .filter(c => c.title.toLowerCase().includes(this.searchBuffer.toLowerCase()));
     }
-    render(firstRender) {
+    render(_firstRender) {
         let output = '';
         const choices = this.getFilteredChoices();
         // Adjust Scroll
@@ -41,7 +41,7 @@ class MultiSelectPrompt extends base_1.Prompt {
         const searchStr = this.searchBuffer ? ` ${theme_1.theme.muted}(Filter: ${this.searchBuffer})${ansi_1.ANSI.RESET}` : '';
         output += `${icon} ${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}`; // No newline at end
+            output += `  ${theme_1.theme.muted}No results found${ansi_1.ANSI.RESET}`;
         }
         else {
             const visible = choices.slice(this.scrollTop, this.scrollTop + this.pageSize);
@@ -57,6 +57,10 @@ class MultiSelectPrompt extends base_1.Prompt {
                 output += `${cursor} ${checkbox} ${choice.title}`;
             });
         }
+        // Hints
+        if (!this.searchBuffer && !this.errorMsg) {
+            output += `\n${ansi_1.ANSI.DIM}(Ctrl+A: All, Ctrl+X: None)${ansi_1.ANSI.RESET}`;
+        }
         if (this.errorMsg) {
             output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
         }
@@ -64,6 +68,7 @@ class MultiSelectPrompt extends base_1.Prompt {
     }
     handleInput(char) {
         const choices = this.getFilteredChoices();
+        // Enter
         if (char === '\r' || char === '\n') {
             const selectedCount = this.checkedState.filter(Boolean).length;
             const { min = 0, max } = this.options;
@@ -83,6 +88,35 @@ class MultiSelectPrompt extends base_1.Prompt {
             this.submit(results);
             return;
         }
+        // --- Batch Shortcuts (Visible Items Only) ---
+        // Ctrl+A (\x01): Select All Visible
+        if (char === '\x01') {
+            const newCheckedState = [...this.checkedState];
+            let potentialAdd = 0;
+            // Calculate potential selections
+            choices.forEach(c => {
+                if (!newCheckedState[c.originalIndex])
+                    potentialAdd++;
+            });
+            const currentSelected = newCheckedState.filter(Boolean).length;
+            if (this.options.max && (currentSelected + potentialAdd) > this.options.max) {
+                this.errorMsg = `Max limit ${this.options.max} reached`;
+            }
+            else {
+                choices.forEach(c => newCheckedState[c.originalIndex] = true);
+                this.checkedState = newCheckedState;
+                this.errorMsg = '';
+            }
+            this.render(false);
+            return;
+        }
+        // Ctrl+X (\x18): Deselect All Visible
+        if (char === '\x18') {
+            choices.forEach(c => this.checkedState[c.originalIndex] = false);
+            this.errorMsg = '';
+            this.render(false);
+            return;
+        }
         if (char === ' ') {
             if (choices.length > 0) {
                 const choice = choices[this.selectedIndex];
@@ -92,14 +126,14 @@ class MultiSelectPrompt extends base_1.Prompt {
             }
             return;
         }
-        if (this.isUp(char)) { // Up
+        if (this.isUp(char)) {
             if (choices.length > 0) {
                 this.selectedIndex = (this.selectedIndex - 1 + choices.length) % choices.length;
                 this.render(false);
             }
             return;
         }
-        if (this.isDown(char)) { // Down
+        if (this.isDown(char)) {
             if (choices.length > 0) {
                 this.selectedIndex = (this.selectedIndex + 1) % choices.length;
                 this.render(false);
@@ -114,6 +148,7 @@ class MultiSelectPrompt extends base_1.Prompt {
             }
             return;
         }
+        // Typing search
         if (!/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
             this.searchBuffer += char;
             this.selectedIndex = 0;

package/dist/prompts/number.d.ts

@@ -5,7 +5,7 @@ export declare class NumberPrompt extends Prompt<number, NumberOptions> {
     private cursor;
     private errorMsg;
     constructor(options: NumberOptions);
-    protected render(firstRender: boolean): void;
+    protected render(_firstRender: boolean): void;
     protected handleInput(char: string): void;
     protected handleMouse(event: MouseEvent): void;
 }