mepcli 0.2.7 → 0.4.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`, 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,15 @@ 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
+    });
+
+    console.log({ name, age, newsletter, lang, tools, stars });
 }
 
 main();
@@ -86,10 +95,23 @@ 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.
 
+## Mouse Support
+
+MepCLI automatically detects modern terminals and enables **Mouse Tracking** (using SGR 1006 protocol).
+
+*   **Scrolling:**
+    *   `select`, `multiSelect`, `checkbox`: Scroll to navigate the list.
+    *   `number`, `slider`, `rating`, `date`: Scroll to increment/decrement values or fields.
+    *   `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
 
 This project is under the **MIT 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.
@@ -47,6 +53,11 @@ export declare abstract class Prompt<T, O> {
      * Render Method with Diffing (Virtual DOM for CLI).
      * Calculates new lines, compares with old lines, and updates only changed parts.
      */
+    /**
+     * Renders the current frame by clearing the previous output and writing the new content.
+     * This approach ("Move Up -> Erase Down -> Print") is more robust against artifacts
+     * than line-by-line diffing, especially when the number of lines changes (e.g., filtering).
+     */
     protected renderFrame(content: string): void;
     protected stripAnsi(str: string): string;
     protected truncate(str: string, width: number): string;

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);
         }
@@ -93,170 +111,37 @@ class Prompt {
      * Render Method with Diffing (Virtual DOM for CLI).
      * Calculates new lines, compares with old lines, and updates only changed parts.
      */
+    /**
+     * Renders the current frame by clearing the previous output and writing the new content.
+     * This approach ("Move Up -> Erase Down -> Print") is more robust against artifacts
+     * than line-by-line diffing, especially when the number of lines changes (e.g., filtering).
+     */
     renderFrame(content) {
-        // Ensure lines are truncated to terminal width
         const width = this.stdout.columns || 80;
         const rawLines = content.split('\n');
-        // Truncate each line and prepare the new buffer
+        // Truncate each line to fit terminal width to avoid wrapping issues
         const newLines = rawLines.map(line => this.truncate(line, width));
-        // Cursor logic:
-        // We assume the cursor is currently at the END of the last rendered frame.
-        // But to diff, it's easier to always reset to the top of the frame first.
-        // 1. Move Cursor to Top of the Frame
+        // 1. Move cursor to the start of the current line
+        this.print(ansi_1.ANSI.CURSOR_LEFT);
+        // 2. Move cursor up to the top of the previously rendered frame
         if (this.lastRenderHeight > 0) {
-            this.print(`\x1b[${this.lastRenderHeight}A`); // Move up N lines
-            // Actually, if last height was 1 (just one line), we move up 1 line?
-            // "A\n" -> 2 lines. Cursor at bottom.
-            // If we move up, we are at top.
-            // Wait, if lastRenderHeight includes the "current line" which is usually empty if we printed with newlines?
-            // Let's stick to: we printed N lines. Cursor is at line N+1 (start).
-            // To go to line 1, we move up N lines.
-            this.print(`\x1b[${this.lastRenderHeight}A`);
+            // If the previous render had multiple lines, move up to the first line
+            if (this.lastRenderHeight > 1) {
+                this.print(`\x1b[${this.lastRenderHeight - 1}A`);
+            }
         }
-        this.print(ansi_1.ANSI.CURSOR_LEFT);
-        // 2. Diff and Render
-        // We iterate through newLines.
-        // For each line, check if it matches lastRenderLines[i].
+        // 3. Clear everything from the cursor down
+        // This ensures all previous content (including "ghost" lines) is removed
+        this.print(ansi_1.ANSI.ERASE_DOWN);
+        // 4. Print the new frame content
         for (let i = 0; i < newLines.length; i++) {
-            const newLine = newLines[i];
-            const oldLine = this.lastRenderLines[i];
-            if (newLine !== oldLine) {
-                // Move to this line if not already there?
-                // We are writing sequentially, so after writing line i-1 (or skipping it),
-                // the cursor might not be at the start of line i if we skipped.
-                // Strategy:
-                // If we skipped lines, we need to jump down.
-                // But simpler: just move cursor to line i relative to top.
-                // \x1b[<N>B moves down N lines.
-                // But we are processing sequentially.
-                // If we are at line 0 (Top).
-                // Process line 0. 
-                // If changed, write it + \n (or clear line + write).
-                // If unchanged, move cursor down 1 line.
-                // Wait, if we use \n at end of write, cursor moves down.
-                // If we skip writing, we must manually move down.
-                this.print(ansi_1.ANSI.ERASE_LINE); // Clear current line
-                this.print(newLine);
-            }
-            // Prepare for next line
+            this.print(newLines[i]);
+            // Add newline character between lines, but not after the last line
             if (i < newLines.length - 1) {
-                // If we wrote something, we are at end of line (maybe wrapped?).
-                // Since we truncate, we are not wrapped.
-                // But we didn't print \n yet if we just printed newLine.
-                // To move to next line start:
                 this.print('\n');
             }
         }
-        // 3. Clear remaining lines if new output is shorter
-        if (newLines.length < this.lastRenderLines.length) {
-            // We are at the last line of new output.
-            // BUG FIX: If the last line was unchanged, we skipped printing.
-            // The cursor is currently at the START of that line (or end of previous).
-            // We need to ensure we move to the NEXT line (or end of current) before clearing down.
-            // If we just finished loop `i = newLines.length - 1`, we are theoretically at the end of the content.
-            // However, since we might have skipped the last line, we need to be careful.
-            // Let's force move to the end of the visual content we just defined.
-            // Actually, simplest way: Just move cursor to start of line N (where N = newLines.length).
-            // Currently we are at line newLines.length - 1.
-            // We need to move down 1 line?
-            // If newLines has 1 line. Loop runs 0.
-            // If skipped, we are at start of line 0.
-            // We need to be at line 1 to clear from there down.
-            // But we didn't print \n.
-            // So: move cursor to (newLines.length) relative to top.
-            // We started at Top.
-            // We iterated newLines.
-            // We injected \n between lines.
-            // The cursor is implicitly tracking where we are.
-            // IF we skipped, we are physically at start of line `i`.
-            // We need to move over it.
-            // Fix: After the loop, explicitly move to the line AFTER the last line.
-            // Since we know where we started (Top), we can just jump to line `newLines.length`.
-            // But we are in relative movement land.
-            // Let's calculate where we *should* be: End of content.
-            // If we just rendered N lines, we want to be at line N+1 (conceptually) to clear below?
-            // Or just at the start of line N+1?
-            // If we have 2 lines. 
-            // Line 0. \n. Line 1.
-            // Cursor is at end of Line 1.
-            // If we skipped Line 1, cursor is at start of Line 1.
-            // We want to clear everything BELOW Line 1.
-            // So we should be at start of Line 2.
-            // Logic:
-            // 1. We are currently at the cursor position after processing `newLines`.
-            //    If last line was skipped, we are at start of last line.
-            //    If last line was written, we are at end of last line.
-            // 2. We want to erase from the line *following* the last valid line.
-            // We can just calculate the difference and move down if needed.
-            // But simpler: Move cursor to the conceptual "end" of the new frame.
-            // If we processed `newLines.length` lines.
-            // We want to be at row `newLines.length` (0-indexed) to start clearing?
-            // No, rows are 0 to N-1.
-            // We want to clear starting from row N.
-            // Since we can't easily query cursor pos, let's use the fact we reset to Top.
-            // We can move to row N relative to current? 
-            // Wait, `ERASE_DOWN` clears from cursor to end of screen.
-            // If we are at start of Line 1 (and it's valid), `ERASE_DOWN` deletes Line 1!
-            // So we MUST be past Line 1.
-            // If we skipped the last line, we must strictly move past it.
-            // How? `\x1b[1B` (Down).
-            // But we don't track if we skipped the last line explicitly outside the loop.
-            // Let's just track `currentLineIndex`.
-            // Alternate robust approach:
-            // After loop, we forcefully move cursor to `newLines.length` lines down from Top.
-            // We are currently at some unknown state (Start or End of last line).
-            // BUT we can just move UP to Top again and then move DOWN N lines.
-            // That feels safe.
-            // Reset to top of frame (which we are already inside/near).
-            // But we don't know exactly where we are relative to top anymore.
-            // Let's rely on the loop index.
-            // If loop finished, `i` was `newLines.length`.
-            // If `newLines.length > 0`.
-            // If we skipped the last line (index `len-1`), we are at start of it.
-            // If we wrote it, we are at end of it.
-            // If we skipped, we need `\x1b[1B`.
-            // If we wrote, we are at end. `ERASE_DOWN` from end of line clears rest of line + below.
-            // BUT we want to clear BELOW.
-            // `ERASE_DOWN` (J=0) clears from cursor to end of screen.
-            // If at end of line, it clears rest of that line (nothing) and lines below. Correct.
-            // So the issue is ONLY when we skipped the last line.
-            const lastLineIdx = newLines.length - 1;
-            if (lastLineIdx >= 0 && newLines[lastLineIdx] === this.lastRenderLines[lastLineIdx]) {
-                // We skipped the last line. Move down 1 line to ensure we don't delete it.
-                // Also move to start (CR) to be safe?
-                this.print('\n');
-                // Wait, \n moves down AND to start usually. 
-                // But strictly \n is Line Feed (Down). \r is Carriage Return (Left).
-                // Console usually treats \n as \r\n in cooked mode, but in raw mode?
-                // We are in raw mode.
-                // We likely need \r\n or explicit movement.
-                // Let's just use \x1b[1B (Down) and \r (Left).
-                // Actually, if we use `\n` in loop, we rely on it working.
-                // Let's assume `\x1b[1B` is safer for "just move down".
-                // But wait, if we are at start of line, `1B` puts us at start of next line.
-                // `ERASE_DOWN` there is perfect.
-                this.print('\x1b[1B');
-                this.print('\r'); // Move to start
-            }
-            else {
-                // We wrote the last line. We are at the end of it.
-                // `ERASE_DOWN` will clear lines below.
-                // BUT if we want to clear the REST of the screen cleanly starting from next line...
-                // It's mostly fine.
-                // However, there is a subtle case: 
-                // If we wrote the line, we are at the end of it.
-                // If we call ERASE_DOWN, it keeps current line intact (from cursor onwards, which is empty).
-                // And clears below.
-                // This is correct.
-                // EXCEPT: If the old screen had MORE lines, we want to clear them.
-                // If we are at end of Line N-1.
-                // Line N exists in old screen.
-                // ERASE_DOWN clears Line N etc.
-                // Correct.
-            }
-            this.print(ansi_1.ANSI.ERASE_DOWN);
-        }
-        // Update state
+        // 5. Update state for the next render cycle
         this.lastRenderLines = newLines;
         this.lastRenderHeight = newLines.length;
     }
@@ -272,10 +157,6 @@ class Prompt {
         // We iterate and sum width until we hit limit - 3
         let currentWidth = 0;
         let cutIndex = 0;
-        // We need to iterate by Code Point or Grapheme to be safe?
-        // Let's use simple char iteration for speed, but respect ANSI.
-        // Actually, reusing the logic from stringWidth might be best but 
-        // we need the index.
         let inAnsi = false;
         for (let i = 0; i < str.length; i++) {
             const code = str.charCodeAt(i);

package/dist/core.d.ts

@@ -1,4 +1,4 @@
-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 } from './types';
 /**
  * Public Facade for MepCLI
  */
@@ -20,4 +20,5 @@ 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>;
 }

package/dist/core.js

@@ -3,6 +3,7 @@ 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 text_1 = require("./prompts/text");
 const select_1 = require("./prompts/select");
 const checkbox_1 = require("./prompts/checkbox");
@@ -14,6 +15,7 @@ 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");
 /**
  * Public Facade for MepCLI
  */
@@ -22,7 +24,7 @@ class MepCLI {
      * Shows a spinner while a promise is pending.
      */
     static async spin(message, taskPromise) {
-        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        const frames = symbols_1.symbols.spinner;
         let i = 0;
         process.stdout.write(ansi_1.ANSI.HIDE_CURSOR);
         const interval = setInterval(() => {
@@ -32,13 +34,13 @@ class MepCLI {
         try {
             const result = await taskPromise;
             clearInterval(interval);
-            process.stdout.write(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}${MepCLI.theme.success}✔${ansi_1.ANSI.RESET} ${message}\n`);
+            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}✖${ansi_1.ANSI.RESET} ${message}\n`);
+            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;
         }
@@ -79,6 +81,9 @@ class MepCLI {
     static multiSelect(options) {
         return new multi_select_1.MultiSelectPrompt(options).run();
     }
+    static rating(options) {
+        return new rating_1.RatingPrompt(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/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

@@ -4,6 +4,7 @@ exports.CheckboxPrompt = void 0;
 const ansi_1 = require("../ansi");
 const base_1 = require("../base");
 const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
 // --- Implementation: Checkbox Prompt ---
 class CheckboxPrompt extends base_1.Prompt {
     constructor(options) {
@@ -29,7 +30,7 @@ class CheckboxPrompt extends base_1.Prompt {
         }
         let output = '';
         // Header
-        const icon = this.errorMsg ? `${theme_1.theme.error}✖` : `${theme_1.theme.success}?`;
+        const icon = this.errorMsg ? `${theme_1.theme.error}${symbols_1.symbols.cross}` : `${theme_1.theme.success}?`;
         output += `${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}`;
         // List
         const choices = this.options.choices;
@@ -37,11 +38,11 @@ class CheckboxPrompt extends base_1.Prompt {
         visibleChoices.forEach((choice, index) => {
             const actualIndex = this.scrollTop + index;
             output += '\n'; // New line for each item
-            const cursor = actualIndex === this.selectedIndex ? `${theme_1.theme.main}❯${ansi_1.ANSI.RESET}` : ' ';
+            const cursor = actualIndex === this.selectedIndex ? `${theme_1.theme.main}${symbols_1.symbols.pointer}${ansi_1.ANSI.RESET}` : ' ';
             const isChecked = this.checkedState[actualIndex];
             const checkbox = isChecked
-                ? `${theme_1.theme.success}◉${ansi_1.ANSI.RESET}`
-                : `${theme_1.theme.muted}◯${ansi_1.ANSI.RESET}`;
+                ? `${theme_1.theme.success}${symbols_1.symbols.checked}${ansi_1.ANSI.RESET}`
+                : `${theme_1.theme.muted}${symbols_1.symbols.unchecked}${ansi_1.ANSI.RESET}`;
             const title = actualIndex === this.selectedIndex
                 ? `${theme_1.theme.main}${choice.title}${ansi_1.ANSI.RESET}`
                 : choice.title;
@@ -110,5 +111,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;
 }