mepcli 0.6.1 → 1.0.0-beta.2

package/dist/prompts/data-inspector.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataInspectorPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const utils_1 = require("../utils");
+const symbols_1 = require("../symbols");
+class DataInspectorPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.cursor = 0;
+        this.flatList = [];
+        this.expandedPaths = new Set();
+        this.scrollTop = 0;
+        this.pageSize = 15;
+        // Edit Mode State
+        this.editMode = false;
+        this.editBuffer = '';
+        this.rootData = options.data; // We mutate this directly
+        this.expandedPaths.add('root'); // Always expand root if it's an object
+        this.recalculateFlatList();
+    }
+    getType(value) {
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'undefined';
+        if (Array.isArray(value))
+            return 'array';
+        if (value instanceof Date)
+            return 'date';
+        return typeof value;
+    }
+    recalculateFlatList() {
+        this.flatList = [];
+        this.traverse(this.rootData, 'root', 0, null, 'root');
+    }
+    traverse(data, key, depth, parentRef, currentPath) {
+        const type = this.getType(data);
+        const isLeaf = !['object', 'array'].includes(type) || data === null;
+        const node = {
+            key: String(key),
+            value: data,
+            type,
+            depth,
+            path: currentPath,
+            parentRef,
+            refKey: key,
+            isLeaf
+        };
+        this.flatList.push(node);
+        if (!isLeaf && this.expandedPaths.has(currentPath)) {
+            const keys = Object.keys(data);
+            keys.forEach(k => {
+                this.traverse(data[k], k, depth + 1, data, `${currentPath}.${k}`);
+            });
+        }
+    }
+    getValueColor(type) {
+        switch (type) {
+            case 'string': return ansi_1.ANSI.FG_GREEN;
+            case 'number': return ansi_1.ANSI.FG_YELLOW;
+            case 'boolean': return ansi_1.ANSI.FG_MAGENTA;
+            case 'null':
+            case 'undefined': return ansi_1.ANSI.FG_GRAY;
+            case 'date': return ansi_1.ANSI.FG_BLUE;
+            default: return ansi_1.ANSI.RESET;
+        }
+    }
+    formatValue(value, type) {
+        if (type === 'string')
+            return `"${value}"`;
+        if (type === 'date')
+            return value.toISOString();
+        if (type === 'array')
+            return `Array(${value.length})`;
+        if (type === 'object')
+            return `Object{${Object.keys(value).length}}`;
+        return String(value);
+    }
+    render(_firstRender) {
+        let 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`;
+        if (this.cursor < this.scrollTop) {
+            this.scrollTop = this.cursor;
+        }
+        else if (this.cursor >= this.scrollTop + this.pageSize) {
+            this.scrollTop = this.cursor - this.pageSize + 1;
+        }
+        const visible = this.flatList.slice(this.scrollTop, this.scrollTop + this.pageSize);
+        visible.forEach((node, index) => {
+            const actualIndex = this.scrollTop + index;
+            const isSelected = actualIndex === this.cursor;
+            // Indentation & Tree Lines
+            const indent = '  '.repeat(node.depth);
+            const prefix = isSelected ? `${theme_1.theme.main}${symbols_1.symbols.pointer} ` : '  ';
+            // Icon
+            let icon = '';
+            if (!node.isLeaf) {
+                icon = this.expandedPaths.has(node.path) ? '▾ ' : '▸ ';
+            }
+            else {
+                icon = '• '; // Leaf
+            }
+            // Key
+            let keyStr = node.key;
+            if (node.path === 'root')
+                keyStr = 'ROOT';
+            // Value Representation
+            let valueStr = '';
+            if (isSelected && this.editMode) {
+                // Editing View
+                valueStr = `${ansi_1.ANSI.BG_BLUE}${ansi_1.ANSI.FG_WHITE} ${this.editBuffer}_ ${ansi_1.ANSI.RESET}`;
+            }
+            else {
+                // Normal View
+                const color = this.getValueColor(node.type);
+                const formatted = this.formatValue(node.value, node.type);
+                valueStr = `${color}${formatted}${ansi_1.ANSI.RESET}`;
+            }
+            // Type Label (Right aligned or just dimmed next to key)
+            const typeLabel = `${ansi_1.ANSI.FG_GRAY}(${node.type})${ansi_1.ANSI.RESET}`;
+            let line = `${indent}${icon}${ansi_1.ANSI.BOLD}${keyStr}${ansi_1.ANSI.RESET}: ${valueStr} ${typeLabel}`;
+            if (isSelected && !this.editMode) {
+                line = `${theme_1.theme.main}${(0, utils_1.stripAnsi)(line)}${ansi_1.ANSI.RESET}`; // Highlight whole line
+            }
+            else if (isSelected && this.editMode) {
+                // In edit mode, we don't highlight the whole line, just the input box
+                line = `${indent}${icon}${ansi_1.ANSI.BOLD}${keyStr}${ansi_1.ANSI.RESET}: ${valueStr} ${typeLabel}`;
+            }
+            output += `${prefix}${line}\n`;
+        });
+        // Footer
+        if (this.editMode) {
+            output += `\n${theme_1.theme.main}EDIT MODE${ansi_1.ANSI.RESET} Enter: Save, Esc: Cancel`;
+        }
+        else {
+            output += `\n${theme_1.theme.muted}(Arrows: Nav, Space: Toggle, Enter: Edit/Submit)${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    handleInput(char, key) {
+        if (this.editMode) {
+            this.handleEditInput(char, key);
+            return;
+        }
+        const node = this.flatList[this.cursor];
+        if (this.isUp(char)) {
+            this.cursor = (this.cursor - 1 + this.flatList.length) % this.flatList.length;
+            this.render(false);
+            return;
+        }
+        if (this.isDown(char)) {
+            this.cursor = (this.cursor + 1) % this.flatList.length;
+            this.render(false);
+            return;
+        }
+        // Expand/Collapse
+        if (char === ' ' || this.isRight(char) || this.isLeft(char)) {
+            if (!node.isLeaf) {
+                const isExpanded = this.expandedPaths.has(node.path);
+                if (this.isRight(char) && !isExpanded) {
+                    this.expandedPaths.add(node.path);
+                }
+                else if (this.isLeft(char) && isExpanded) {
+                    this.expandedPaths.delete(node.path);
+                }
+                else if (char === ' ') {
+                    if (isExpanded)
+                        this.expandedPaths.delete(node.path);
+                    else
+                        this.expandedPaths.add(node.path);
+                }
+                else if (this.isLeft(char) && !isExpanded && node.parentRef) {
+                    // Jump to parent
+                    // This requires finding parent index, but simplification: just do nothing or standard logic
+                }
+                this.recalculateFlatList();
+                this.render(false);
+            }
+            return;
+        }
+        // Enter: Edit or Submit
+        if (char === '\r' || char === '\n') {
+            if (node.path === 'root') {
+                this.submit(this.rootData);
+                return;
+            }
+            // Toggle Boolean immediately
+            if (node.type === 'boolean') {
+                const newVal = !node.value;
+                node.parentRef[node.refKey] = newVal;
+                this.recalculateFlatList(); // Value changed
+                this.render(false);
+                return;
+            }
+            // Enter Edit Mode for String/Number
+            if (['string', 'number'].includes(node.type)) {
+                this.editMode = true;
+                this.editBuffer = String(node.value);
+                this.render(false);
+                return;
+            }
+            this.submit(this.rootData);
+        }
+    }
+    handleEditInput(char, key) {
+        const node = this.flatList[this.cursor];
+        // Enter: Save
+        if (char === '\r' || char === '\n') {
+            let newValue = this.editBuffer;
+            if (node.type === 'number') {
+                newValue = Number(this.editBuffer);
+                if (isNaN(newValue))
+                    newValue = 0; // Fallback
+            }
+            // Update Data
+            node.parentRef[node.refKey] = newValue;
+            this.editMode = false;
+            this.recalculateFlatList();
+            this.render(false);
+            return;
+        }
+        // Esc: Cancel
+        if (key[0] === 27 && key.length === 1) { // Standard ESC
+            this.editMode = false;
+            this.render(false);
+            return;
+        }
+        // Backspace
+        if (key.toString() === '\x7f' || char === '\b') {
+            this.editBuffer = this.editBuffer.slice(0, -1);
+            this.render(false);
+            return;
+        }
+        // Typing
+        if (char && char.length === 1 && char.charCodeAt(0) >= 32) {
+            this.editBuffer += char;
+            this.render(false);
+        }
+    }
+    handleMouse(event) {
+        if (this.editMode)
+            return; // Disable scroll in edit mode for now
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.cursor = (this.cursor - 1 + this.flatList.length) % this.flatList.length;
+            }
+            else if (event.scroll === 'down') {
+                this.cursor = (this.cursor + 1) % this.flatList.length;
+            }
+            this.render(false);
+        }
+    }
+}
+exports.DataInspectorPrompt = DataInspectorPrompt;

package/dist/prompts/dependency.d.ts

@@ -0,0 +1,16 @@
+import { Prompt } from '../base';
+import { DependencyOptions, MouseEvent } from '../types';
+export declare class DependencyPrompt<V> extends Prompt<V[], DependencyOptions<V>> {
+    private selectedIndex;
+    private checkedState;
+    private errorMsg;
+    private warningMsg;
+    private scrollTop;
+    private readonly pageSize;
+    constructor(options: DependencyOptions<V>);
+    private resolveDependencies;
+    protected render(_firstRender: boolean): void;
+    protected handleMouse(event: MouseEvent): void;
+    protected handleInput(char: string): void;
+    private validateDependencies;
+}

package/dist/prompts/dependency.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+class DependencyPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.selectedIndex = 0;
+        this.errorMsg = '';
+        this.warningMsg = '';
+        // Pagination state
+        this.scrollTop = 0;
+        this.pageSize = 10;
+        // Initialize checked state from options (default selected)
+        // We also need to run initial validation/resolution
+        this.checkedState = options.choices.map(c => !!c.selected);
+        if (options.autoResolve !== false) {
+            // Run resolution for all initially selected items
+            this.checkedState.forEach((isChecked, i) => {
+                if (isChecked) {
+                    this.resolveDependencies(i, true);
+                }
+            });
+        }
+    }
+    resolveDependencies(index, value) {
+        // If autoResolve is false, we don't do anything automatically, 
+        // validation will handle it on submit.
+        if (this.options.autoResolve === false)
+            return;
+        const choices = this.options.choices;
+        const visited = new Set();
+        const queue = [];
+        queue.push({ idx: index, val: value });
+        // Process queue
+        let loops = 0;
+        while (queue.length > 0 && loops < 1000) { // Safety break
+            loops++;
+            const current = queue.shift();
+            if (visited.has(current.idx))
+                continue;
+            // Apply state
+            // Only if it changes state
+            if (this.checkedState[current.idx] !== current.val) {
+                this.checkedState[current.idx] = current.val;
+                if (current.reason) {
+                    this.warningMsg = current.reason;
+                }
+            }
+            visited.add(current.idx);
+            const currentItem = choices[current.idx];
+            if (current.val) {
+                // Turning ON
+                // 1. Check Conflicts (Disable them)
+                if (currentItem.conflictsWith) {
+                    currentItem.conflictsWith.forEach(conflictVal => {
+                        const conflictIdx = choices.findIndex(c => c.value === conflictVal);
+                        if (conflictIdx !== -1 && this.checkedState[conflictIdx]) {
+                            queue.push({
+                                idx: conflictIdx,
+                                val: false,
+                                reason: `Disabled ${choices[conflictIdx].title} due to conflict with ${currentItem.title}`
+                            });
+                        }
+                    });
+                }
+                // 2. Check Dependencies (Enable them)
+                if (currentItem.dependsOn) {
+                    currentItem.dependsOn.forEach(depVal => {
+                        const depIdx = choices.findIndex(c => c.value === depVal);
+                        if (depIdx !== -1 && !this.checkedState[depIdx]) {
+                            queue.push({
+                                idx: depIdx,
+                                val: true,
+                                reason: `Enabled ${choices[depIdx].title} because ${currentItem.title} requires it`
+                            });
+                        }
+                    });
+                }
+                // 3. Check Triggers (Enable them)
+                if (currentItem.triggers) {
+                    currentItem.triggers.forEach(trigVal => {
+                        const trigIdx = choices.findIndex(c => c.value === trigVal);
+                        if (trigIdx !== -1 && !this.checkedState[trigIdx]) {
+                            queue.push({
+                                idx: trigIdx,
+                                val: true,
+                                reason: `Triggered ${choices[trigIdx].title} from ${currentItem.title}`
+                            });
+                        }
+                    });
+                }
+            }
+            else {
+                // Turning OFF
+                // Check if other ON items depend on this one. If so, disable them.
+                choices.forEach((other, otherIdx) => {
+                    if (this.checkedState[otherIdx] && other.dependsOn && other.dependsOn.includes(currentItem.value)) {
+                        queue.push({
+                            idx: otherIdx,
+                            val: false,
+                            reason: `Disabled ${other.title} because it depends on ${currentItem.title}`
+                        });
+                    }
+                });
+            }
+        }
+    }
+    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;
+        }
+        if (this.options.choices.length <= this.pageSize) {
+            this.scrollTop = 0;
+        }
+        let output = '';
+        // Header
+        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}(Space: toggle, Enter: submit)${ansi_1.ANSI.RESET}`;
+        // List
+        const choices = this.options.choices;
+        const visibleChoices = choices.slice(this.scrollTop, this.scrollTop + this.pageSize);
+        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}${symbols_1.symbols.pointer}${ansi_1.ANSI.RESET}` : ' ';
+            const isChecked = this.checkedState[actualIndex];
+            const checkbox = isChecked
+                ? `${theme_1.theme.success}${symbols_1.symbols.checked}${ansi_1.ANSI.RESET}`
+                : `${theme_1.theme.muted}${symbols_1.symbols.unchecked}${ansi_1.ANSI.RESET}`;
+            let title = actualIndex === this.selectedIndex
+                ? `${theme_1.theme.main}${choice.title}${ansi_1.ANSI.RESET}`
+                : choice.title;
+            // Add tags for relationships
+            if (choice.dependsOn && choice.dependsOn.length > 0) {
+                title += ` ${theme_1.theme.muted}[Req: ${choice.dependsOn.length}]${ansi_1.ANSI.RESET}`;
+            }
+            if (choice.conflictsWith && choice.conflictsWith.length > 0) {
+                title += ` ${theme_1.theme.error}[Con: ${choice.conflictsWith.length}]${ansi_1.ANSI.RESET}`;
+            }
+            output += `${cursor} ${checkbox} ${title}`;
+        });
+        if (this.errorMsg) {
+            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
+        }
+        else if (this.warningMsg) {
+            output += `\n${theme_1.theme.main}>> ${this.warningMsg}${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.options.choices.length - 1;
+                this.render(false);
+            }
+            else if (event.scroll === 'down') {
+                this.selectedIndex = this.selectedIndex < this.options.choices.length - 1 ? this.selectedIndex + 1 : 0;
+                this.render(false);
+            }
+        }
+    }
+    handleInput(char) {
+        if (char === '\r' || char === '\n') {
+            // Final Validation
+            const selectedCount = this.checkedState.filter(Boolean).length;
+            const { min = 0, max } = this.options;
+            if (selectedCount < min) {
+                this.errorMsg = `You must select at least ${min} options.`;
+                this.render(false);
+                return;
+            }
+            if (max && selectedCount > max) {
+                this.errorMsg = `You can only select up to ${max} options.`;
+                this.render(false);
+                return;
+            }
+            // Dependency Logic Check (if autoResolve was off, or double check)
+            // Even if autoResolve is on, we check for cycles or invalid states that might have slipped? 
+            // Or just check if manual toggle left things broken (if autoResolve is OFF).
+            if (this.options.autoResolve === false) {
+                const invalid = this.validateDependencies();
+                if (invalid) {
+                    this.errorMsg = invalid;
+                    this.render(false);
+                    return;
+                }
+            }
+            this.cleanup();
+            const results = this.options.choices
+                .filter((_, i) => this.checkedState[i])
+                .map(c => c.value);
+            this.submit(results);
+            return;
+        }
+        // Space Toggle
+        if (char === ' ') {
+            const currentChecked = this.checkedState[this.selectedIndex];
+            // Toggle
+            const newState = !currentChecked;
+            // Check Max limit before enabling
+            if (newState) {
+                const selectedCount = this.checkedState.filter(Boolean).length;
+                const { max } = this.options;
+                if (max && selectedCount >= max) {
+                    this.errorMsg = `Max ${max} selections allowed.`;
+                    this.render(false);
+                    return;
+                }
+            }
+            this.errorMsg = '';
+            this.warningMsg = '';
+            if (this.options.autoResolve !== false) {
+                this.resolveDependencies(this.selectedIndex, newState);
+            }
+            else {
+                this.checkedState[this.selectedIndex] = newState;
+            }
+            this.render(false);
+        }
+        if (this.isUp(char)) { // Up
+            this.selectedIndex = this.selectedIndex > 0 ? this.selectedIndex - 1 : this.options.choices.length - 1;
+            this.render(false);
+        }
+        if (this.isDown(char)) { // Down
+            this.selectedIndex = this.selectedIndex < this.options.choices.length - 1 ? this.selectedIndex + 1 : 0;
+            this.render(false);
+        }
+    }
+    validateDependencies() {
+        const choices = this.options.choices;
+        for (let i = 0; i < choices.length; i++) {
+            if (!this.checkedState[i])
+                continue;
+            const item = choices[i];
+            // Check dependencies
+            if (item.dependsOn) {
+                for (const depVal of item.dependsOn) {
+                    const depIdx = choices.findIndex(c => c.value === depVal);
+                    if (depIdx === -1 || !this.checkedState[depIdx]) {
+                        return `${item.title} requires ${depVal}`; // Should look up title for depVal ideally
+                    }
+                }
+            }
+            // Check conflicts
+            if (item.conflictsWith) {
+                for (const conVal of item.conflictsWith) {
+                    const conIdx = choices.findIndex(c => c.value === conVal);
+                    if (conIdx !== -1 && this.checkedState[conIdx]) {
+                        return `${item.title} conflicts with ${choices[conIdx].title}`;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+}
+exports.DependencyPrompt = DependencyPrompt;

package/dist/prompts/dial.d.ts

@@ -0,0 +1,10 @@
+import { Prompt } from '../base';
+import { DialOptions, MouseEvent } from '../types';
+export declare class DialPrompt extends Prompt<number, DialOptions> {
+    private currentValue;
+    constructor(options: DialOptions);
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string, _key: Buffer): void;
+    protected handleMouse(event: MouseEvent): void;
+    private updateValue;
+}

package/dist/prompts/dial.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialPrompt = void 0;
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const ansi_1 = require("../ansi");
+class DialPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.currentValue = options.initial !== undefined ? options.initial : options.min;
+        // Clamp initial
+        if (this.currentValue < this.options.min)
+            this.currentValue = this.options.min;
+        if (this.currentValue > this.options.max)
+            this.currentValue = this.options.max;
+    }
+    render(_firstRender) {
+        // Round value for display if necessary
+        const displayValue = Math.round(this.currentValue * 100) / 100;
+        let output = `${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${theme_1.theme.main}${displayValue}${ansi_1.ANSI.RESET}\n`;
+        const radius = this.options.radius || 5;
+        // Adjust aspect ratio: terminal chars are ~2x taller than wide.
+        // So we multiply X by 2.
+        const centerX = radius * 2;
+        const centerY = radius;
+        const width = centerX * 2 + 1;
+        const height = centerY * 2 + 1;
+        // Initialize grid
+        const grid = [];
+        for (let y = 0; y < height; y++) {
+            const row = [];
+            for (let x = 0; x < width; x++) {
+                row.push(' ');
+            }
+            grid.push(row);
+        }
+        // Draw track (static circle arc)
+        // Knob usually goes from Bottom-Left (135 deg) to Bottom-Right (405 deg)
+        // 0 deg is Right. 90 deg is Down.
+        for (let a = 135; a <= 405; a += 10) {
+            const rad = a * Math.PI / 180;
+            const rX = Math.round(centerX + radius * Math.cos(rad) * 2);
+            const rY = Math.round(centerY + radius * Math.sin(rad));
+            if (rY >= 0 && rY < height && rX >= 0 && rX < width) {
+                grid[rY][rX] = `${ansi_1.ANSI.FG_GRAY}·${ansi_1.ANSI.RESET}`;
+            }
+        }
+        // Calculate Pointer Position
+        const totalRange = this.options.max - this.options.min;
+        // Avoid division by zero
+        const percent = totalRange === 0 ? 0 : (this.currentValue - this.options.min) / totalRange;
+        const angleDeg = 135 + (percent * 270);
+        const rad = angleDeg * Math.PI / 180;
+        const ptrX = Math.round(centerX + radius * Math.cos(rad) * 2);
+        const ptrY = Math.round(centerY + radius * Math.sin(rad));
+        if (ptrY >= 0 && ptrY < height && ptrX >= 0 && ptrX < width) {
+            grid[ptrY][ptrX] = `${theme_1.theme.main}${this.options.pointerSymbol || '●'}${ansi_1.ANSI.RESET}`;
+        }
+        // Draw Center Value (Optional - roughly centered)
+        // const valStr = displayValue.toString();
+        // const valX = centerX - Math.floor(valStr.length / 2);
+        // const valY = centerY;
+        // if (valY >= 0 && valY < height && valX >= 0 && valX + valStr.length <= width) {
+        //    for (let i = 0; i < valStr.length; i++) {
+        //        // grid[valY][valX + i] = valStr[i];
+        //    }
+        // }
+        // Construct string
+        for (let y = 0; y < height; y++) {
+            output += '  ' + grid[y].join('') + '\n';
+        }
+        // Instructions
+        output += `\n${ansi_1.ANSI.FG_GRAY}(Arrows/Scroll to adjust, Enter to submit)${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+    handleInput(char, _key) {
+        const step = this.options.step || 1;
+        if (this.isLeft(char) || this.isDown(char)) {
+            this.updateValue(this.currentValue - step);
+        }
+        else if (this.isRight(char) || this.isUp(char)) {
+            this.updateValue(this.currentValue + step);
+        }
+        else if (char === '\r' || char === '\n') {
+            this.submit(this.currentValue);
+        }
+    }
+    handleMouse(event) {
+        const step = this.options.step || 1;
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.updateValue(this.currentValue + step);
+            }
+            else {
+                this.updateValue(this.currentValue - step);
+            }
+        }
+    }
+    updateValue(val) {
+        if (val < this.options.min)
+            val = this.options.min;
+        if (val > this.options.max)
+            val = this.options.max;
+        if (this.currentValue !== val) {
+            this.currentValue = val;
+            this.render(false);
+        }
+    }
+}
+exports.DialPrompt = DialPrompt;

package/dist/prompts/diff.d.ts

@@ -0,0 +1,10 @@
+import { Prompt } from '../base';
+import { DiffOptions } from '../types';
+export declare class DiffPrompt extends Prompt<string, DiffOptions> {
+    private activeAction;
+    private actions;
+    constructor(options: DiffOptions);
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string, _key: Buffer): void;
+    private handleSubmit;
+}