mepcli 0.3.0 → 0.5.0

package/dist/prompts/date.js

@@ -37,6 +37,18 @@ class DatePrompt extends base_1.Prompt {
     }
     handleInput(char) {
         if (char === '\r' || char === '\n') {
+            // Min constraint check
+            if (this.options.min && this.value < this.options.min) {
+                this.errorMsg = 'Date cannot be before minimum allowed.';
+                this.render(false);
+                return;
+            }
+            // Max constraint check
+            if (this.options.max && this.value > this.options.max) {
+                this.errorMsg = 'Date cannot be after maximum allowed.';
+                this.render(false);
+                return;
+            }
             this.submit(this.value);
             return;
         }
@@ -89,7 +101,16 @@ class DatePrompt extends base_1.Prompt {
             else if (this.selectedField === 4)
                 d.setMinutes(Math.max(0, Math.min(59, finalVal)));
             this.value = d;
-            this.errorMsg = '';
+            // Check immediately after updating the value to display an error message (but still allow further input)
+            if (this.options.min && this.value < this.options.min) {
+                this.errorMsg = 'Warning: Date is before minimum.';
+            }
+            else if (this.options.max && this.value > this.options.max) {
+                this.errorMsg = 'Warning: Date is after maximum.';
+            }
+            else {
+                this.errorMsg = '';
+            }
             this.render(false);
             return;
         }
@@ -99,39 +120,49 @@ class DatePrompt extends base_1.Prompt {
         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;
+            this.adjustDate(dir);
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.adjustDate(1);
             }
-            if (valid) {
-                this.value = d;
-                this.errorMsg = '';
+            else if (event.scroll === 'down') {
+                this.adjustDate(-1);
             }
-            this.render(false);
         }
     }
+    adjustDate(dir) {
+        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;
+        }
+        this.value = d;
+        if (this.options.min && this.value < this.options.min) {
+            this.errorMsg = 'Date cannot be before minimum allowed.';
+        }
+        else if (this.options.max && this.value > this.options.max) {
+            this.errorMsg = 'Date cannot be after maximum allowed.';
+        }
+        else {
+            this.errorMsg = '';
+        }
+        this.render(false);
+    }
 }
 exports.DatePrompt = DatePrompt;

package/dist/prompts/file.js

@@ -131,12 +131,6 @@ class FilePrompt extends base_1.Prompt {
         // Move right
         const prefix = `${icon} ${theme_1.theme.title}${this.options.message} `;
         const prefixLen = this.stripAnsi(prefix).length;
-        // Cursor is usually at the end of input unless we add backspace support etc.
-        // The cursor property tracks it, but my handleInput simplified it.
-        // Let's rely on this.input.length for now since handleInput appends.
-        // Ah, handleInput logic below supports cursor pos theoretically but I only see appending?
-        // Actually handleInput doesn't support left/right in the original code, it supports down/up for suggestions.
-        // So cursor is always at end.
         const targetCol = prefixLen + this.input.length;
         this.print(ansi_1.ANSI.CURSOR_LEFT);
         if (targetCol > 0)

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

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

package/dist/prompts/multi-select.js

@@ -120,5 +120,20 @@ class MultiSelectPrompt extends base_1.Prompt {
             this.render(false);
         }
     }
+    handleMouse(event) {
+        const choices = this.getFilteredChoices();
+        if (choices.length === 0)
+            return;
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.selectedIndex = (this.selectedIndex - 1 + choices.length) % choices.length;
+                this.render(false);
+            }
+            else if (event.scroll === 'down') {
+                this.selectedIndex = (this.selectedIndex + 1) % choices.length;
+                this.render(false);
+            }
+        }
+    }
 }
 exports.MultiSelectPrompt = MultiSelectPrompt;

package/dist/prompts/number.d.ts

@@ -1,5 +1,5 @@
 import { Prompt } from '../base';
-import { NumberOptions } from '../types';
+import { NumberOptions, MouseEvent } from '../types';
 export declare class NumberPrompt extends Prompt<number, NumberOptions> {
     private stringValue;
     private cursor;
@@ -7,4 +7,5 @@ export declare class NumberPrompt extends Prompt<number, NumberOptions> {
     constructor(options: NumberOptions);
     protected render(firstRender: boolean): void;
     protected handleInput(char: string): void;
+    protected handleMouse(event: MouseEvent): void;
 }

package/dist/prompts/number.js

@@ -130,5 +130,27 @@ class NumberPrompt extends base_1.Prompt {
             this.render(false);
         }
     }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            let num = parseFloat(this.stringValue) || 0;
+            const step = this.options.step ?? 1;
+            if (event.scroll === 'up') {
+                num += step;
+                if (this.options.max !== undefined && num > this.options.max)
+                    num = this.options.max;
+            }
+            else if (event.scroll === 'down') {
+                num -= step;
+                if (this.options.min !== undefined && num < this.options.min)
+                    num = this.options.min;
+            }
+            // Round to avoid float errors
+            num = Math.round(num * 10000) / 10000;
+            this.stringValue = num.toString();
+            this.cursor = this.stringValue.length;
+            this.errorMsg = '';
+            this.render(false);
+        }
+    }
 }
 exports.NumberPrompt = NumberPrompt;

package/dist/prompts/rating.d.ts

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

package/dist/prompts/rating.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RatingPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+class RatingPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        // Default to min if initial is not provided
+        this.value = options.initial ?? (options.min || 1);
+    }
+    render(firstRender) {
+        const min = this.options.min || 1;
+        const max = this.options.max || 5;
+        // Render stars
+        let stars = '';
+        for (let i = min; i <= max; i++) {
+            if (i <= this.value) {
+                stars += `${theme_1.theme.success}${symbols_1.symbols.star}${ansi_1.ANSI.RESET} `;
+            }
+            else {
+                stars += `${theme_1.theme.muted}${symbols_1.symbols.starEmpty}${ansi_1.ANSI.RESET} `;
+            }
+        }
+        const output = `${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${stars}`;
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        const min = this.options.min || 1;
+        const max = this.options.max || 5;
+        if (char === '\r' || char === '\n') {
+            this.submit(this.value);
+            return;
+        }
+        // Arrow keys
+        if (this.isLeft(char) || this.isDown(char)) { // Left/Down decreases
+            if (this.value > min) {
+                this.value--;
+                this.render(false);
+            }
+        }
+        else if (this.isRight(char) || this.isUp(char)) { // Right/Up increases
+            if (this.value < max) {
+                this.value++;
+                this.render(false);
+            }
+        }
+        // Number keys (1-9)
+        const num = parseInt(char);
+        if (!isNaN(num)) {
+            if (num >= min && num <= max) {
+                this.value = num;
+                this.render(false);
+            }
+        }
+    }
+    handleMouse(event) {
+        const min = this.options.min || 1;
+        const max = this.options.max || 5;
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                if (this.value < max) {
+                    this.value++;
+                    this.render(false);
+                }
+            }
+            else if (event.scroll === 'down') {
+                if (this.value > min) {
+                    this.value--;
+                    this.render(false);
+                }
+            }
+        }
+    }
+}
+exports.RatingPrompt = RatingPrompt;

package/dist/prompts/select.d.ts

@@ -1,5 +1,5 @@
 import { Prompt } from '../base';
-import { SelectOptions } from '../types';
+import { SelectOptions, MouseEvent } from '../types';
 export declare class SelectPrompt<V> extends Prompt<any, SelectOptions<V>> {
     private selectedIndex;
     private searchBuffer;
@@ -11,4 +11,5 @@ export declare class SelectPrompt<V> extends Prompt<any, SelectOptions<V>> {
     private getFilteredChoices;
     protected render(firstRender: boolean): void;
     protected handleInput(char: string): void;
+    protected handleMouse(event: MouseEvent): void;
 }

package/dist/prompts/select.js

@@ -145,5 +145,20 @@ class SelectPrompt extends base_1.Prompt {
             this.render(false);
         }
     }
+    handleMouse(event) {
+        const choices = this.getFilteredChoices();
+        if (choices.length === 0)
+            return;
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.selectedIndex = this.findNextSelectableIndex(this.selectedIndex, -1);
+                this.render(false);
+            }
+            else if (event.scroll === 'down') {
+                this.selectedIndex = this.findNextSelectableIndex(this.selectedIndex, 1);
+                this.render(false);
+            }
+        }
+    }
 }
 exports.SelectPrompt = SelectPrompt;

package/dist/prompts/slider.d.ts

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

package/dist/prompts/slider.js

@@ -46,5 +46,19 @@ class SliderPrompt extends base_1.Prompt {
             this.render(false);
         }
     }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            const step = this.options.step || 1;
+            if (event.scroll === 'up') { // Scroll Up -> Increase
+                this.value = Math.min(this.options.max, this.value + step);
+            }
+            if (event.scroll === 'down') { // Scroll Down -> Decrease
+                this.value = Math.max(this.options.min, this.value - step);
+            }
+            // Round to avoid float errors
+            this.value = Math.round(this.value * 10000) / 10000;
+            this.render(false);
+        }
+    }
 }
 exports.SliderPrompt = SliderPrompt;

package/dist/prompts/sort.d.ts

@@ -0,0 +1,14 @@
+import { Prompt } from '../base';
+import { SortOptions, MouseEvent } from '../types';
+export declare class SortPrompt extends Prompt<string[], SortOptions> {
+    private items;
+    private selectedIndex;
+    private grabbedIndex;
+    private scrollTop;
+    private readonly pageSize;
+    constructor(options: SortOptions);
+    protected render(firstRender: boolean): void;
+    protected handleInput(char: string): void;
+    private swap;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/sort.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SortPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+class SortPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.selectedIndex = 0;
+        this.grabbedIndex = null;
+        this.scrollTop = 0;
+        this.pageSize = 10;
+        this.items = [...options.items];
+    }
+    render(firstRender) {
+        // Adjust Scroll Top
+        if (this.selectedIndex < this.scrollTop) {
+            this.scrollTop = this.selectedIndex;
+        }
+        else if (this.selectedIndex >= this.scrollTop + this.pageSize) {
+            this.scrollTop = this.selectedIndex - this.pageSize + 1;
+        }
+        // Ensure valid scroll (handle list shrinking?) - list doesn't shrink here but good practice
+        this.scrollTop = Math.max(0, Math.min(this.scrollTop, this.items.length - this.pageSize));
+        if (this.scrollTop < 0)
+            this.scrollTop = 0;
+        let output = '';
+        // Header
+        output += `${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}(Press <space> to grab, arrows to move, <enter> to confirm)${ansi_1.ANSI.RESET}\n`;
+        const visibleItems = this.items.slice(this.scrollTop, this.scrollTop + this.pageSize);
+        visibleItems.forEach((item, index) => {
+            const actualIndex = this.scrollTop + index;
+            if (index > 0)
+                output += '\n';
+            const isSelected = actualIndex === this.selectedIndex;
+            const isGrabbed = actualIndex === this.grabbedIndex;
+            // Pointer
+            let prefix = '  ';
+            if (isSelected) {
+                if (isGrabbed) {
+                    prefix = `${theme_1.theme.main}${symbols_1.symbols.pointer}${symbols_1.symbols.pointer} `; // Double pointer for grabbed?
+                }
+                else {
+                    prefix = `${theme_1.theme.main}${symbols_1.symbols.pointer} `;
+                }
+            }
+            else if (isGrabbed) {
+                // Should not happen if we move grabbed item with cursor
+                // But if logic differs, maybe.
+            }
+            // Item Content
+            let content = item;
+            if (isGrabbed) {
+                content = `${ansi_1.ANSI.BOLD}${theme_1.theme.main}${content}${ansi_1.ANSI.RESET}`;
+            }
+            else if (isSelected) {
+                content = `${theme_1.theme.main}${content}${ansi_1.ANSI.RESET}`;
+            }
+            // Index indicator? Maybe not needed, minimalist.
+            output += `${prefix}${content}`;
+        });
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        // Enter
+        if (char === '\r' || char === '\n') {
+            this.submit(this.items);
+            return;
+        }
+        // Space (Grab/Drop)
+        if (char === ' ') {
+            if (this.grabbedIndex === null) {
+                this.grabbedIndex = this.selectedIndex;
+            }
+            else {
+                this.grabbedIndex = null;
+            }
+            this.render(false);
+            return;
+        }
+        // Up
+        if (this.isUp(char)) {
+            if (this.grabbedIndex !== null) {
+                // Move item up
+                if (this.selectedIndex > 0) {
+                    const newIndex = this.selectedIndex - 1;
+                    this.swap(this.selectedIndex, newIndex);
+                    this.selectedIndex = newIndex;
+                    this.grabbedIndex = newIndex;
+                }
+            }
+            else {
+                // Move cursor up
+                this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.items.length - 1;
+            }
+            this.render(false);
+            return;
+        }
+        // Down
+        if (this.isDown(char)) {
+            if (this.grabbedIndex !== null) {
+                // Move item down
+                if (this.selectedIndex < this.items.length - 1) {
+                    const newIndex = this.selectedIndex + 1;
+                    this.swap(this.selectedIndex, newIndex);
+                    this.selectedIndex = newIndex;
+                    this.grabbedIndex = newIndex;
+                }
+            }
+            else {
+                // Move cursor down
+                this.selectedIndex = this.selectedIndex < this.items.length - 1 ? this.selectedIndex + 1 : 0;
+            }
+            this.render(false);
+            return;
+        }
+    }
+    swap(i, j) {
+        [this.items[i], this.items[j]] = [this.items[j], this.items[i]];
+    }
+    // Mouse support? 
+    // Drag and drop is hard with just clicks/scroll. 
+    // Maybe click to grab, scroll to move?
+    handleMouse(event) {
+        // Simple scroll support for navigation
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                if (this.grabbedIndex !== null) {
+                    if (this.selectedIndex > 0) {
+                        const newIndex = this.selectedIndex - 1;
+                        this.swap(this.selectedIndex, newIndex);
+                        this.selectedIndex = newIndex;
+                        this.grabbedIndex = newIndex;
+                    }
+                }
+                else {
+                    this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.items.length - 1;
+                }
+                this.render(false);
+            }
+            else if (event.scroll === 'down') {
+                if (this.grabbedIndex !== null) {
+                    if (this.selectedIndex < this.items.length - 1) {
+                        const newIndex = this.selectedIndex + 1;
+                        this.swap(this.selectedIndex, newIndex);
+                        this.selectedIndex = newIndex;
+                        this.grabbedIndex = newIndex;
+                    }
+                }
+                else {
+                    this.selectedIndex = this.selectedIndex < this.items.length - 1 ? this.selectedIndex + 1 : 0;
+                }
+                this.render(false);
+            }
+        }
+    }
+}
+exports.SortPrompt = SortPrompt;

package/dist/prompts/table.d.ts

@@ -0,0 +1,14 @@
+import { Prompt } from '../base';
+import { TableOptions, MouseEvent } from '../types';
+export declare class TablePrompt<V> extends Prompt<V, TableOptions<V>> {
+    private selectedIndex;
+    private scrollTop;
+    private readonly pageSize;
+    private colWidths;
+    constructor(options: TableOptions<V>);
+    private calculateColWidths;
+    protected render(firstRender: boolean): void;
+    private pad;
+    protected handleInput(char: string): void;
+    protected handleMouse(event: MouseEvent): void;
+}

package/dist/prompts/table.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TablePrompt = 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 TablePrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.selectedIndex = 0;
+        this.scrollTop = 0;
+        this.colWidths = [];
+        this.pageSize = options.rows || 7;
+        this.calculateColWidths();
+    }
+    calculateColWidths() {
+        const { columns, data } = this.options;
+        this.colWidths = columns.map(c => (0, utils_1.stringWidth)(c));
+        data.forEach(row => {
+            row.row.forEach((cell, idx) => {
+                if (idx < this.colWidths.length) {
+                    this.colWidths[idx] = Math.max(this.colWidths[idx], (0, utils_1.stringWidth)(cell));
+                }
+            });
+        });
+        // Add padding
+        this.colWidths = this.colWidths.map(w => w + 2);
+    }
+    render(firstRender) {
+        // Scroll Logic
+        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 maxScroll = Math.max(0, this.options.data.length - this.pageSize);
+        this.scrollTop = Math.min(this.scrollTop, maxScroll);
+        let output = '';
+        // Title
+        output += `${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        // Table Header
+        let headerStr = '  '; // Indent for pointer space
+        this.options.columns.forEach((col, i) => {
+            headerStr += this.pad(col, this.colWidths[i]);
+        });
+        output += `${ansi_1.ANSI.BOLD}${headerStr}${ansi_1.ANSI.RESET}\n`;
+        // Table Body
+        const visibleRows = this.options.data.slice(this.scrollTop, this.scrollTop + this.pageSize);
+        visibleRows.forEach((item, index) => {
+            const actualIndex = this.scrollTop + index;
+            if (index > 0)
+                output += '\n';
+            const isSelected = actualIndex === this.selectedIndex;
+            const pointer = isSelected ? `${theme_1.theme.main}${symbols_1.symbols.pointer}${ansi_1.ANSI.RESET} ` : '  ';
+            let rowStr = '';
+            item.row.forEach((cell, colIdx) => {
+                const width = this.colWidths[colIdx];
+                let cellStr = this.pad(cell, width);
+                if (isSelected) {
+                    cellStr = `${theme_1.theme.main}${cellStr}${ansi_1.ANSI.RESET}`;
+                }
+                rowStr += cellStr;
+            });
+            output += `${pointer}${rowStr}`;
+        });
+        this.renderFrame(output);
+    }
+    pad(str, width) {
+        const len = (0, utils_1.stringWidth)(str);
+        if (len >= width)
+            return str;
+        return str + ' '.repeat(width - len);
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            this.submit(this.options.data[this.selectedIndex].value);
+            return;
+        }
+        if (this.isUp(char)) {
+            this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.options.data.length - 1;
+            this.render(false);
+            return;
+        }
+        if (this.isDown(char)) {
+            this.selectedIndex = this.selectedIndex < this.options.data.length - 1 ? this.selectedIndex + 1 : 0;
+            this.render(false);
+            return;
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.options.data.length - 1;
+                this.render(false);
+            }
+            else if (event.scroll === 'down') {
+                this.selectedIndex = this.selectedIndex < this.options.data.length - 1 ? this.selectedIndex + 1 : 0;
+                this.render(false);
+            }
+        }
+    }
+}
+exports.TablePrompt = TablePrompt;