mepcli 0.3.0 → 0.5.0

package/README.md

@@ -5,14 +5,15 @@
 ## Features
 
 - **Zero Dependency:** Keeps your project clean and fast.
-- **Comprehensive Prompts:** Includes `text`, `password`, `select`, `checkbox`, `confirm`, `number`, `toggle`, `list`, `slider`, `date`, `file`, and `multiSelect`.
+- **Comprehensive Prompts:** Includes `text`, `password`, `select`, `checkbox`, `confirm`, `number`, `toggle`, `list`, `slider`, `date`, `file`, `multiSelect`, `autocomplete`, `sort`, `table`, and `rating`.
+- **Mouse Support:** Built-in support for mouse interaction (SGR 1006 protocol). Scroll to navigate lists or change values; click to select.
 - **Responsive Input:** Supports cursor movement (Left/Right) and character insertion/deletion in text-based prompts.
 - **Validation:** Built-in support for input validation (sync and async) with custom error messages.
 - **Elegant Look:** Uses ANSI colors for a clean, modern CLI experience.
 
 ## Installation
 
-```bash
+```shell
 npm install mepcli
 # or
 yarn add mepcli
@@ -66,7 +67,44 @@ async function main() {
         ]
     });
 
-    console.log({ name, age, newsletter, lang, tools });
+    // Rating (Star rating)
+    const stars = await MepCLI.rating({
+        message: "Rate your experience:",
+        min: 1,
+        max: 5,
+        initial: 5
+    });
+
+    // Autocomplete (Search)
+    const city = await MepCLI.autocomplete({
+        message: "Search for a city:",
+        suggest: async (query) => {
+            const cities = [
+                { title: "New York", value: "NY" },
+                { title: "London", value: "LDN" },
+                { title: "Paris", value: "PAR" }
+            ];
+            return cities.filter(c => c.title.toLowerCase().includes(query.toLowerCase()));
+        }
+    });
+
+    // Sort (Drag & Drop)
+    const priorities = await MepCLI.sort({
+        message: "Rank priorities:",
+        items: ["Speed", "Quality", "Cost"]
+    });
+
+    // Table (Data selection)
+    const user = await MepCLI.table({
+        message: "Select a user:",
+        columns: ["ID", "Name"],
+        data: [
+            { value: 1, row: ["001", "Alice"] },
+            { value: 2, row: ["002", "Bob"] }
+        ]
+    });
+
+    console.log({ name, age, newsletter, lang, tools, stars, city, priorities, user });
 }
 
 main();
@@ -86,9 +124,26 @@ main();
 *   `checkbox(options)` - Classic checkbox selection.
 *   `list(options)` - Enter a list of tags/strings.
 *   `slider(options)` - Select a number within a range using a visual slider.
+*   `rating(options)` - Star rating input.
 *   `date(options)` - Date and time picker.
 *   `file(options)` - File system navigator and selector.
-*   `spin(message, promise)` - Display a spinner while waiting for a promise.
+*   `autocomplete(options)` - Searchable selection with async suggestions.
+*   `sort(options)` - Reorder a list of items.
+*   `table(options)` - Display data in columns and select rows.
+*   `spinner(message)` - Returns a `Spinner` instance for manual control (`start`, `stop`, `update`, `success`, `error`).
+
+## Mouse Support
+
+MepCLI automatically detects modern terminals and enables **Mouse Tracking** (using SGR 1006 protocol).
+
+*   **Scrolling:**
+    *   `select`, `multiSelect`, `checkbox`, `autocomplete`, `table`: Scroll to navigate the list.
+    *   `number`, `slider`, `rating`, `date`: Scroll to increment/decrement values or fields.
+    *   `sort`: Scroll to navigate or reorder items (when grabbed).
+    *   `toggle`, `confirm`: Scroll to toggle the state.
+*   **Configuration:**
+    *   Mouse support is enabled by default if the terminal supports it.
+    *   You can explicitly disable it per prompt by setting `mouse: false` in the options.
 
 ## License
 

package/dist/ansi.d.ts

@@ -21,4 +21,7 @@ export declare const ANSI: {
     SHOW_CURSOR: string;
     UP: string;
     DOWN: string;
+    SET_ANY_EVENT_MOUSE: string;
+    SET_SGR_EXT_MODE_MOUSE: string;
+    DISABLE_MOUSE: string;
 };

package/dist/ansi.js

@@ -26,4 +26,8 @@ exports.ANSI = {
     SHOW_CURSOR: '\x1b[?25h',
     UP: '\x1b[A',
     DOWN: '\x1b[B',
+    // Mouse Tracking (SGR Protocol)
+    SET_ANY_EVENT_MOUSE: '\x1b[?1003h',
+    SET_SGR_EXT_MODE_MOUSE: '\x1b[?1006h',
+    DISABLE_MOUSE: '\x1b[?1003l\x1b[?1006l',
 };

package/dist/base.d.ts

@@ -1,3 +1,4 @@
+import { MouseEvent } from './types';
 import { detectCapabilities } from './utils';
 /**
  * Abstract base class for all prompts.
@@ -29,6 +30,11 @@ export declare abstract class Prompt<T, O> {
      * @param key The raw buffer.
      */
     protected abstract handleInput(char: string, key: Buffer): void;
+    /**
+     * Optional method to handle mouse events.
+     * Subclasses can override this to implement mouse interaction.
+     */
+    protected handleMouse(event: MouseEvent): void;
     protected print(text: string): void;
     /**
      * Starts the prompt interaction.

package/dist/base.js

@@ -20,6 +20,11 @@ class Prompt {
         this._inputParser = new input_1.InputParser();
         this.capabilities = (0, utils_1.detectCapabilities)();
     }
+    /**
+     * Optional method to handle mouse events.
+     * Subclasses can override this to implement mouse interaction.
+     */
+    handleMouse(event) { }
     print(text) {
         this.stdout.write(text);
     }
@@ -36,6 +41,12 @@ class Prompt {
             }
             this.stdin.resume();
             this.stdin.setEncoding('utf8');
+            // Enable Mouse Tracking if supported and requested
+            // Default to true if capabilities support it, unless explicitly disabled in options
+            const shouldEnableMouse = this.options.mouse !== false && this.capabilities.hasMouse;
+            if (shouldEnableMouse) {
+                this.print(ansi_1.ANSI.SET_ANY_EVENT_MOUSE + ansi_1.ANSI.SET_SGR_EXT_MODE_MOUSE);
+            }
             // Initial render: Default to hidden cursor (good for menus)
             // Subclasses like TextPrompt will explicitly show it if needed.
             if (this.capabilities.isCI) {
@@ -57,6 +68,10 @@ class Prompt {
                 this.handleInput(char, buffer);
             };
             this._inputParser.on('keypress', this._onKeyHandler);
+            // Listen to mouse events
+            this._inputParser.on('mouse', (event) => {
+                this.handleMouse(event);
+            });
             this._onDataHandler = (buffer) => {
                 this._inputParser.feed(buffer);
             };
@@ -73,6 +88,9 @@ class Prompt {
         if (this._onKeyHandler) {
             this._inputParser.removeListener('keypress', this._onKeyHandler);
         }
+        // Cleanup mouse listener - though InputParser is instance specific, so it's fine.
+        // Disable Mouse Tracking
+        this.print(ansi_1.ANSI.DISABLE_MOUSE);
         if (typeof this.stdin.setRawMode === 'function') {
             this.stdin.setRawMode(false);
         }

package/dist/core.d.ts

@@ -1,13 +1,14 @@
-import { TextOptions, SelectOptions, ConfirmOptions, CheckboxOptions, ThemeConfig, NumberOptions, ToggleOptions, ListOptions, SliderOptions, DateOptions, FileOptions, MultiSelectOptions } from './types';
+import { TextOptions, SelectOptions, ConfirmOptions, CheckboxOptions, ThemeConfig, NumberOptions, ToggleOptions, ListOptions, SliderOptions, DateOptions, FileOptions, MultiSelectOptions, RatingOptions, AutocompleteOptions, SortOptions, TableOptions } from './types';
+import { Spinner } from './spinner';
 /**
  * Public Facade for MepCLI
  */
 export declare class MepCLI {
     static theme: ThemeConfig;
     /**
-     * Shows a spinner while a promise is pending.
+     * Creates a new Spinner instance.
      */
-    static spin<T>(message: string, taskPromise: Promise<T>): Promise<T>;
+    static spinner(message: string): Spinner;
     static text(options: TextOptions): Promise<string>;
     static select<const V>(options: SelectOptions<V>): Promise<V>;
     static checkbox<const V>(options: CheckboxOptions<V>): Promise<V[]>;
@@ -20,4 +21,8 @@ export declare class MepCLI {
     static date(options: DateOptions): Promise<Date>;
     static file(options: FileOptions): Promise<string>;
     static multiSelect<const V>(options: MultiSelectOptions<V>): Promise<V[]>;
+    static rating(options: RatingOptions): Promise<number>;
+    static autocomplete<const V>(options: AutocompleteOptions<V>): Promise<V>;
+    static sort(options: SortOptions): Promise<string[]>;
+    static table<const V>(options: TableOptions<V>): Promise<V>;
 }

package/dist/core.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MepCLI = void 0;
-const ansi_1 = require("./ansi");
 const theme_1 = require("./theme");
-const symbols_1 = require("./symbols");
+const spinner_1 = require("./spinner");
 const text_1 = require("./prompts/text");
 const select_1 = require("./prompts/select");
 const checkbox_1 = require("./prompts/checkbox");
@@ -15,34 +14,19 @@ const slider_1 = require("./prompts/slider");
 const date_1 = require("./prompts/date");
 const file_1 = require("./prompts/file");
 const multi_select_1 = require("./prompts/multi-select");
+const rating_1 = require("./prompts/rating");
+const autocomplete_1 = require("./prompts/autocomplete");
+const sort_1 = require("./prompts/sort");
+const table_1 = require("./prompts/table");
 /**
  * Public Facade for MepCLI
  */
 class MepCLI {
     /**
-     * Shows a spinner while a promise is pending.
+     * Creates a new Spinner instance.
      */
-    static async spin(message, taskPromise) {
-        const frames = symbols_1.symbols.spinner;
-        let i = 0;
-        process.stdout.write(ansi_1.ANSI.HIDE_CURSOR);
-        const interval = setInterval(() => {
-            process.stdout.write(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}${MepCLI.theme.main}${frames[i]}${ansi_1.ANSI.RESET} ${message}`);
-            i = (i + 1) % frames.length;
-        }, 80);
-        try {
-            const result = await taskPromise;
-            clearInterval(interval);
-            process.stdout.write(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}${MepCLI.theme.success}${symbols_1.symbols.tick}${ansi_1.ANSI.RESET} ${message}\n`);
-            process.stdout.write(ansi_1.ANSI.SHOW_CURSOR);
-            return result;
-        }
-        catch (error) {
-            clearInterval(interval);
-            process.stdout.write(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}${MepCLI.theme.error}${symbols_1.symbols.cross}${ansi_1.ANSI.RESET} ${message}\n`);
-            process.stdout.write(ansi_1.ANSI.SHOW_CURSOR);
-            throw error;
-        }
+    static spinner(message) {
+        return new spinner_1.Spinner(message);
     }
     static text(options) {
         return new text_1.TextPrompt(options).run();
@@ -80,6 +64,18 @@ class MepCLI {
     static multiSelect(options) {
         return new multi_select_1.MultiSelectPrompt(options).run();
     }
+    static rating(options) {
+        return new rating_1.RatingPrompt(options).run();
+    }
+    static autocomplete(options) {
+        return new autocomplete_1.AutocompletePrompt(options).run();
+    }
+    static sort(options) {
+        return new sort_1.SortPrompt(options).run();
+    }
+    static table(options) {
+        return new table_1.TablePrompt(options).run();
+    }
 }
 exports.MepCLI = MepCLI;
 MepCLI.theme = theme_1.theme;

package/dist/input.d.ts

@@ -9,5 +9,6 @@ export declare class InputParser extends EventEmitter {
      */
     feed(data: Buffer): void;
     private processChar;
+    private parseSGRMouse;
     private emitKey;
 }

package/dist/input.js

@@ -14,14 +14,6 @@ class InputParser extends events_1.EventEmitter {
      * Feed data into the parser.
      */
     feed(data) {
-        // Convert buffer to string.
-        // For partial multi-byte sequences at the chunk boundary,
-        // buffer.toString() might produce replacement chars.
-        // Ideally we should use StringDecoder, but since we are handling KeyPresses,
-        // and usually a keypress is complete, simple toString often works.
-        // However, the user mentioned fragmentation issues.
-        // But InputParser usually receives data from stdin.
-        // The core issue of fragmentation is splitting escape codes like \x1b [ A
         const input = data.toString('utf-8');
         for (let i = 0; i < input.length; i++) {
             const char = input[i];
@@ -67,6 +59,11 @@ class InputParser extends events_1.EventEmitter {
         }
         else if (this.state === 'CSI') {
             this.buffer += char;
+            if (char === '<') {
+                this.state = 'MOUSE_SGR';
+                this.buffer = '<';
+                return;
+            }
             // CSI sequences end with 0x40-0x7E
             if (char >= '@' && char <= '~') {
                 this.emitKey(this.buffer);
@@ -75,6 +72,63 @@ class InputParser extends events_1.EventEmitter {
             }
             // Otherwise, we keep buffering (params like 1;2)
         }
+        else if (this.state === 'MOUSE_SGR') {
+            this.buffer += char;
+            // SGR sequences end with 'm' (release) or 'M' (press)
+            if (char === 'm' || char === 'M') {
+                this.parseSGRMouse(this.buffer);
+                this.buffer = '';
+                this.state = 'NORMAL';
+            }
+        }
+    }
+    parseSGRMouse(buffer) {
+        // console.log('Parsing SGR:', buffer);
+        // format: <b;x;yM or <b;x;ym
+        // buffer includes the leading < and trailing M/m
+        const content = buffer.slice(1, -1);
+        const type = buffer.slice(-1); // m or M
+        const parts = content.split(';').map(Number);
+        if (parts.length >= 3) {
+            const [b, x, y] = parts;
+            let action = 'press';
+            // Interpret button codes
+            // 0: Left, 1: Middle, 2: Right
+            // +32: Motion
+            // 64: Scroll Up
+            // 65: Scroll Down
+            if (b === 64) {
+                action = 'scroll';
+                this.emit('mouse', { name: 'mouse', x, y, button: 0, action, scroll: 'up' });
+                // Also emit keypress for scroll if needed? No, prompt should listen to mouse.
+                // But for "Easy Features", we emit standard names
+                this.emit('scrollup');
+                return;
+            }
+            if (b === 65) {
+                action = 'scroll';
+                this.emit('mouse', { name: 'mouse', x, y, button: 0, action, scroll: 'down' });
+                this.emit('scrolldown');
+                return;
+            }
+            if (type === 'm') {
+                action = 'release';
+            }
+            else {
+                action = 'press';
+                // Check if motion
+                if (b & 32) {
+                    action = 'move';
+                }
+            }
+            this.emit('mouse', {
+                name: 'mouse',
+                x,
+                y,
+                button: b & 3, // Strip modifiers to get raw button 0-2
+                action
+            });
+        }
     }
     emitKey(key) {
         // Normalize Enter

package/dist/prompts/autocomplete.d.ts

@@ -0,0 +1,22 @@
+import { Prompt } from '../base';
+import { AutocompleteOptions, MouseEvent } from '../types';
+export declare class AutocompletePrompt<V> extends Prompt<V, AutocompleteOptions<V>> {
+    private input;
+    private choices;
+    private selectedIndex;
+    private loading;
+    private debounceTimer?;
+    private spinnerFrame;
+    private spinnerTimer?;
+    private scrollTop;
+    private readonly pageSize;
+    private hasSearched;
+    constructor(options: AutocompleteOptions<V>);
+    private search;
+    private startSpinner;
+    private stopSpinner;
+    protected cleanup(): void;
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/autocomplete.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutocompletePrompt = 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 AutocompletePrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.input = '';
+        this.choices = [];
+        this.selectedIndex = 0;
+        this.loading = false;
+        this.spinnerFrame = 0;
+        this.scrollTop = 0;
+        this.pageSize = 7;
+        this.hasSearched = false;
+        this.input = options.initial || '';
+        this.search(this.input);
+    }
+    search(query) {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.loading = true;
+        this.startSpinner();
+        this.render(false);
+        this.debounceTimer = setTimeout(async () => {
+            try {
+                const results = await this.options.suggest(query);
+                if (query !== this.input)
+                    return;
+                this.choices = results.slice(0, this.options.limit || 10);
+                this.selectedIndex = 0;
+                this.scrollTop = 0;
+                this.hasSearched = true;
+            }
+            catch (err) {
+                this.choices = [];
+            }
+            finally {
+                this.loading = false;
+                this.stopSpinner();
+                this.render(false);
+            }
+        }, 300); // 300ms debounce
+    }
+    startSpinner() {
+        if (this.spinnerTimer)
+            return;
+        this.spinnerTimer = setInterval(() => {
+            this.spinnerFrame = (this.spinnerFrame + 1) % symbols_1.symbols.spinner.length;
+            this.render(false);
+        }, 80);
+    }
+    stopSpinner() {
+        if (this.spinnerTimer) {
+            clearInterval(this.spinnerTimer);
+            this.spinnerTimer = undefined;
+        }
+    }
+    cleanup() {
+        this.stopSpinner();
+        super.cleanup();
+    }
+    render(firstRender) {
+        // --- FIX START: Restore cursor position ---
+        // renderFrame() in Base assumes the cursor is at the bottom of the output.
+        // Since Autocomplete moves the cursor to the top (for input) after rendering,
+        // we must manually move it back down before the next render cycle.
+        if (this.lastRenderHeight > 1) {
+            this.print(`\x1b[${this.lastRenderHeight - 1}B`); // Move down
+        }
+        // --- FIX END ---
+        let output = '';
+        // Header
+        const icon = this.loading ? `${theme_1.theme.main}${symbols_1.symbols.spinner[this.spinnerFrame]}${ansi_1.ANSI.RESET}` : `${theme_1.theme.success}?${ansi_1.ANSI.RESET}`;
+        output += `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${this.input}`;
+        output += '\n';
+        if (this.loading) {
+            output += `  ${theme_1.theme.muted}Searching...${ansi_1.ANSI.RESET}`;
+        }
+        else if (this.choices.length === 0 && this.hasSearched) {
+            output += `  ${theme_1.theme.muted}${this.options.fallback || 'No results found.'}${ansi_1.ANSI.RESET}`;
+        }
+        else if (this.choices.length > 0) {
+            // Render list similar to SelectPrompt
+            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 visibleChoices = this.choices.slice(this.scrollTop, this.scrollTop + this.pageSize);
+            visibleChoices.forEach((choice, index) => {
+                const actualIndex = this.scrollTop + index;
+                if (index > 0)
+                    output += '\n';
+                if (actualIndex === this.selectedIndex) {
+                    output += `${theme_1.theme.main}${symbols_1.symbols.pointer} ${choice.title}${ansi_1.ANSI.RESET}`;
+                }
+                else {
+                    output += `  ${choice.title}`;
+                }
+            });
+        }
+        this.renderFrame(output);
+        // Position cursor at the end of the input string on the first line
+        const lines = output.split('\n');
+        const height = lines.length;
+        // Move up (height - 1)
+        if (height > 1) {
+            this.print(`\x1b[${height - 1}A`);
+        }
+        this.print(`\r`);
+        const firstLine = lines[0];
+        const visualLen = (0, utils_1.stringWidth)(this.stripAnsi(firstLine));
+        this.print(`\x1b[${visualLen}C`);
+        this.print(ansi_1.ANSI.SHOW_CURSOR);
+    }
+    handleInput(char) {
+        // Enter
+        if (char === '\r' || char === '\n') {
+            if (this.choices.length > 0) {
+                this.submit(this.choices[this.selectedIndex].value);
+            }
+            return;
+        }
+        // Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            if (this.input.length > 0) {
+                this.input = this.input.slice(0, -1);
+                this.search(this.input);
+            }
+            return;
+        }
+        // Up
+        if (this.isUp(char)) {
+            if (this.choices.length > 0) {
+                this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.choices.length - 1;
+                this.render(false);
+            }
+            return;
+        }
+        // Down
+        if (this.isDown(char)) {
+            if (this.choices.length > 0) {
+                this.selectedIndex = this.selectedIndex < this.choices.length - 1 ? this.selectedIndex + 1 : 0;
+                this.render(false);
+            }
+            return;
+        }
+        // Typing
+        if (char.length === 1 && !/^[\x00-\x1F]/.test(char)) {
+            this.input += char;
+            this.search(this.input);
+        }
+    }
+    handleMouse(event) {
+        if (this.choices.length === 0)
+            return;
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.choices.length - 1;
+                this.render(false);
+            }
+            else if (event.scroll === 'down') {
+                this.selectedIndex = this.selectedIndex < this.choices.length - 1 ? this.selectedIndex + 1 : 0;
+                this.render(false);
+            }
+        }
+    }
+}
+exports.AutocompletePrompt = AutocompletePrompt;

package/dist/prompts/checkbox.d.ts

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

package/dist/prompts/checkbox.js

@@ -51,10 +51,6 @@ class CheckboxPrompt extends base_1.Prompt {
         // Indication of more items
         if (choices.length > this.pageSize) {
             const progress = ` ${this.scrollTop + 1}-${Math.min(this.scrollTop + this.pageSize, choices.length)} of ${choices.length}`;
-            // Maybe add this to the header or footer?
-            // Let's add it to footer or header. Adding to header is cleaner.
-            // But I already wrote header.
-            // Let's just append it at the bottom if I want, or ignore for now to keep UI minimal.
         }
         if (this.errorMsg) {
             output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
@@ -111,5 +107,19 @@ class CheckboxPrompt extends base_1.Prompt {
             this.render(false);
         }
     }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.options.choices.length - 1;
+                this.errorMsg = '';
+                this.render(false);
+            }
+            else if (event.scroll === '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

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

package/dist/prompts/confirm.js

@@ -38,5 +38,11 @@ class ConfirmPrompt extends base_1.Prompt {
             this.render(false);
         }
     }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            this.value = !this.value;
+            this.render(false);
+        }
+    }
 }
 exports.ConfirmPrompt = ConfirmPrompt;

package/dist/prompts/date.d.ts

@@ -1,5 +1,5 @@
 import { Prompt } from '../base';
-import { DateOptions } from '../types';
+import { DateOptions, MouseEvent } from '../types';
 export declare class DatePrompt extends Prompt<Date, DateOptions> {
     private selectedField;
     private errorMsg;
@@ -7,4 +7,6 @@ export declare class DatePrompt extends Prompt<Date, DateOptions> {
     constructor(options: DateOptions);
     protected render(firstRender: boolean): void;
     protected handleInput(char: string): void;
+    protected handleMouse(event: MouseEvent): void;
+    private adjustDate;
 }