mepcli 0.5.0 → 0.6.0

package/dist/prompts/snippet.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnippetPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+class SnippetPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.tokens = [];
+        this.variableTokens = []; // Indices in this.tokens
+        this.values = {};
+        this.activeVarIndex = 0; // Index in variableTokens
+        this.cursor = 0; // Cursor in active variable value
+        this.errorMsg = '';
+        this.lastLinesUp = 0;
+        this.parseTemplate();
+        // Initialize values
+        if (options.values) {
+            this.values = { ...options.values };
+        }
+        // Ensure all vars have entries
+        this.variableTokens.forEach(idx => {
+            const varName = this.tokens[idx].value;
+            if (this.values[varName] === undefined) {
+                this.values[varName] = '';
+            }
+        });
+        if (this.variableTokens.length > 0) {
+            const firstVar = this.tokens[this.variableTokens[0]].value;
+            this.cursor = this.values[firstVar].length;
+        }
+    }
+    parseTemplate() {
+        const regex = /\$\{([a-zA-Z0-9_]+)\}/g;
+        let lastIndex = 0;
+        let match;
+        while ((match = regex.exec(this.options.template)) !== null) {
+            if (match.index > lastIndex) {
+                this.tokens.push({ type: 'static', value: this.options.template.substring(lastIndex, match.index) });
+            }
+            this.tokens.push({ type: 'variable', value: match[1] });
+            this.variableTokens.push(this.tokens.length - 1);
+            lastIndex = regex.lastIndex;
+        }
+        if (lastIndex < this.options.template.length) {
+            this.tokens.push({ type: 'static', value: this.options.template.substring(lastIndex) });
+        }
+    }
+    render(firstRender) {
+        if (!firstRender && this.lastLinesUp > 0) {
+            this.print(`\x1b[${this.lastLinesUp}B`);
+        }
+        this.lastLinesUp = 0;
+        // Build the string
+        let output = '';
+        let cursorVisualIndex = 0;
+        let currentVisualIndex = 0;
+        // Prefix/Message
+        const prefix = `${theme_1.theme.success}? ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message || 'Fill snippet'}${ansi_1.ANSI.RESET}\n`;
+        output += prefix;
+        // cursorVisualIndex should start after prefix?
+        // Actually renderFrame handles newlines.
+        // We will construct the snippet line.
+        let snippetLine = '';
+        this.tokens.forEach((token, index) => {
+            if (token.type === 'static') {
+                snippetLine += `${theme_1.theme.muted}${token.value}${ansi_1.ANSI.RESET}`;
+                currentVisualIndex += token.value.length; // assuming simple ascii/static length
+            }
+            else {
+                const isFocused = this.variableTokens[this.activeVarIndex] === index;
+                const val = this.values[token.value] || '';
+                // Placeholder if empty?
+                const displayVal = val.length === 0 && isFocused ? '' : val; // maybe show placeholder?
+                let styledVal = displayVal;
+                if (isFocused) {
+                    styledVal = `${ansi_1.ANSI.UNDERLINE}${theme_1.theme.main}${displayVal}${ansi_1.ANSI.RESET}`;
+                    // Calculate cursor position
+                    cursorVisualIndex = currentVisualIndex + this.cursor;
+                }
+                else {
+                    styledVal = `${theme_1.theme.main}${displayVal}${ansi_1.ANSI.RESET}`;
+                }
+                snippetLine += styledVal;
+                currentVisualIndex += displayVal.length;
+            }
+        });
+        output += snippetLine;
+        if (this.errorMsg) {
+            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
+        }
+        output += `\n${theme_1.theme.muted}(Tab to next variable, Enter to submit)${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+        // Position Cursor
+        this.print(ansi_1.ANSI.SHOW_CURSOR);
+        // We need to move to correct line and column
+        // Lines:
+        // 1. Message
+        // 2. Snippet (cursor here)
+        // 3. Error (optional)
+        // 4. Hint
+        // snippetLine is at index 1 (0-based) if Message has no newlines.
+        // Prefix ends with \n. So snippetLine is on 2nd line.
+        // Calculate which row relative to bottom the snippet line is.
+        // If error: 4 lines total. Snippet is line 1 (2nd). Lines up = 2.
+        // If no error: 3 lines total. Snippet is line 1. Lines up = 1.
+        let linesUp = 1;
+        if (this.errorMsg)
+            linesUp++;
+        if (linesUp > 0) {
+            this.print(`\x1b[${linesUp}A`);
+            this.lastLinesUp = linesUp;
+        }
+        this.print(ansi_1.ANSI.CURSOR_LEFT);
+        if (cursorVisualIndex > 0) {
+            this.print(`\x1b[${cursorVisualIndex}C`);
+        }
+    }
+    handleInput(char, _key) {
+        // Navigation: Tab / Shift+Tab
+        if (char === '\u001b[Z') {
+            // Shift Tab -> Prev
+            this.moveFocus(-1);
+            return;
+        }
+        if (char === '\t') {
+            this.moveFocus(1);
+            return;
+        }
+        // Enter
+        if (char === '\r' || char === '\n') {
+            this.submitSnippet();
+            return;
+        }
+        // Editing
+        const activeTokenIdx = this.variableTokens[this.activeVarIndex];
+        const varName = this.tokens[activeTokenIdx].value;
+        const val = this.values[varName];
+        if (char === '\u0008' || char === '\x7f') { // Backspace
+            if (this.cursor > 0) {
+                const pre = val.slice(0, this.cursor - 1);
+                const post = val.slice(this.cursor);
+                this.values[varName] = pre + post;
+                this.cursor--;
+                this.render(false);
+            }
+            return;
+        }
+        if (this.isLeft(char)) {
+            if (this.cursor > 0)
+                this.cursor--;
+            this.render(false);
+            return;
+        }
+        if (this.isRight(char)) {
+            if (this.cursor < val.length)
+                this.cursor++;
+            this.render(false);
+            return;
+        }
+        if (!/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            const pre = val.slice(0, this.cursor);
+            const post = val.slice(this.cursor);
+            this.values[varName] = pre + char + post;
+            this.cursor += char.length;
+            this.render(false);
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.moveFocus(-1);
+            }
+            else if (event.scroll === 'down') {
+                this.moveFocus(1);
+            }
+        }
+    }
+    moveFocus(direction) {
+        const nextIndex = this.activeVarIndex + direction;
+        if (nextIndex >= 0 && nextIndex < this.variableTokens.length) {
+            this.activeVarIndex = nextIndex;
+            const varName = this.tokens[this.variableTokens[this.activeVarIndex]].value;
+            this.cursor = this.values[varName].length;
+            this.render(false);
+        }
+    }
+    submitSnippet() {
+        // Construct final string
+        let result = '';
+        this.tokens.forEach(token => {
+            if (token.type === 'static') {
+                result += token.value;
+            }
+            else {
+                result += this.values[token.value] || '';
+            }
+        });
+        this.submit(result);
+    }
+}
+exports.SnippetPrompt = SnippetPrompt;

package/dist/prompts/sort.d.ts

@@ -7,7 +7,7 @@ export declare class SortPrompt extends Prompt<string[], SortOptions> {
     private scrollTop;
     private readonly pageSize;
     constructor(options: SortOptions);
-    protected render(firstRender: boolean): void;
+    protected render(_firstRender: boolean): void;
     protected handleInput(char: string): void;
     private swap;
     protected handleMouse(event: MouseEvent): void;

package/dist/prompts/sort.js

@@ -14,7 +14,7 @@ class SortPrompt extends base_1.Prompt {
         this.pageSize = 10;
         this.items = [...options.items];
     }
-    render(firstRender) {
+    render(_firstRender) {
         // Adjust Scroll Top
         if (this.selectedIndex < this.scrollTop) {
             this.scrollTop = this.selectedIndex;
@@ -120,9 +120,6 @@ class SortPrompt extends base_1.Prompt {
     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') {

package/dist/prompts/spam.d.ts

@@ -0,0 +1,17 @@
+import { Prompt } from '../base';
+import { BaseOptions } from '../types';
+interface SpamOptions extends BaseOptions {
+    threshold: number;
+    spamKey?: string;
+    decay?: boolean;
+}
+export declare class SpamPrompt extends Prompt<boolean, SpamOptions> {
+    private count;
+    private width;
+    private decayTimer?;
+    constructor(options: SpamOptions);
+    protected cleanup(): void;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}
+export {};

package/dist/prompts/spam.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpamPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+class SpamPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.count = 0;
+        this.width = 20; // Visual width of the bar
+        if (options.decay) {
+            this.decayTimer = setInterval(() => {
+                if (this.count > 0) {
+                    this.count = Math.max(0, this.count - 1);
+                    this.render(false);
+                }
+            }, 200); // Drop 5 presses per second
+        }
+    }
+    cleanup() {
+        if (this.decayTimer)
+            clearInterval(this.decayTimer);
+        super.cleanup();
+    }
+    render(_firstRender) {
+        const progress = Math.min(this.count / this.options.threshold, 1);
+        const filledLen = Math.round(progress * this.width);
+        const emptyLen = this.width - filledLen;
+        // Visual Bar: [#####-----]
+        const filled = symbols_1.symbols.line.repeat(filledLen).replace(/./g, '#'); // Or use block char
+        const empty = symbols_1.symbols.line.repeat(emptyLen);
+        const barColor = progress === 1 ? theme_1.theme.success : theme_1.theme.error;
+        const bar = `${theme_1.theme.muted}[${barColor}${filled}${theme_1.theme.muted}${empty}]${ansi_1.ANSI.RESET}`;
+        let output = `${theme_1.theme.error}${symbols_1.symbols.cross} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        output += `  ${bar} ${Math.floor(progress * 100)}%`;
+        if (this.count >= this.options.threshold) {
+            output += ` ${theme_1.theme.success} READY! Press Enter${ansi_1.ANSI.RESET}`;
+        }
+        else {
+            output += ` ${theme_1.theme.muted}(Mash '${this.options.spamKey || 'Space'}' to fill)${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        // Confirm execution
+        if (this.count >= this.options.threshold && (char === '\r' || char === '\n')) {
+            this.submit(true);
+            return;
+        }
+        const trigger = this.options.spamKey || ' ';
+        // Check if key matches (or any key if not specified)
+        if (char === trigger) {
+            if (this.count < this.options.threshold) {
+                this.count++;
+                this.render(false);
+            }
+        }
+    }
+}
+exports.SpamPrompt = SpamPrompt;

package/dist/prompts/table.d.ts

@@ -7,7 +7,7 @@ export declare class TablePrompt<V> extends Prompt<V, TableOptions<V>> {
     private colWidths;
     constructor(options: TableOptions<V>);
     private calculateColWidths;
-    protected render(firstRender: boolean): void;
+    protected render(_firstRender: boolean): void;
     private pad;
     protected handleInput(char: string): void;
     protected handleMouse(event: MouseEvent): void;

package/dist/prompts/table.js

@@ -28,7 +28,7 @@ class TablePrompt extends base_1.Prompt {
         // Add padding
         this.colWidths = this.colWidths.map(w => w + 2);
     }
-    render(firstRender) {
+    render(_firstRender) {
         // Scroll Logic
         if (this.selectedIndex < this.scrollTop) {
             this.scrollTop = this.selectedIndex;

package/dist/prompts/text.d.ts

@@ -5,6 +5,7 @@ export declare class TextPrompt extends Prompt<string, TextOptions> {
     private cursor;
     private hasTyped;
     private segments;
+    private lastLinesUp;
     constructor(options: TextOptions);
     protected render(firstRender: boolean): void;
     private getSegmentWidth;

package/dist/prompts/text.js

@@ -15,14 +15,18 @@ class TextPrompt extends base_1.Prompt {
         this.cursor = 0;
         this.hasTyped = false;
         this.segments = [];
+        this.lastLinesUp = 0;
         this.value = options.initial || '';
         // Initialize segments from value
         this.segments = (0, utils_1.safeSplit)(this.value);
         this.cursor = this.segments.length;
     }
     render(firstRender) {
+        if (!firstRender && this.lastLinesUp > 0) {
+            this.print(`\x1b[${this.lastLinesUp}B`);
+        }
+        this.lastLinesUp = 0;
         // Calculate available width
-        const cols = process.stdout.columns || 80;
         // 1. Prepare Prompt Label
         const icon = this.errorMsg ? `${theme_1.theme.error}${symbols_1.symbols.cross}` : `${theme_1.theme.success}?`;
         const hint = this.options.multiline ? ` ${theme_1.theme.muted}(Press Ctrl+D to submit)${ansi_1.ANSI.RESET}` : '';
@@ -43,31 +47,16 @@ class TextPrompt extends base_1.Prompt {
             cursorRelativeCol = 0;
         }
         else {
-            const rawValue = this.options.isPassword ? '*'.repeat(this.segments.length) : this.value;
+            const maskChar = this.options.mask ?? (this.options.isPassword ? '*' : undefined);
             // Note: password masking replaces each grapheme with '*'
             // Split by lines (for multiline support)
-            const lines = rawValue.split('\n');
             // Determine which line the cursor is on
             // We need to map 'cursor' (segments index) to line/col.
             // This is tricky because segments might contain '\n'.
             // safeSplit treats '\n' as a segment.
             let cursorLineIndex = 0;
-            let cursorSegmentIndexOnLine = 0;
-            let currentSegmentIndex = 0;
-            for (let i = 0; i < lines.length; i++) {
-                // How many segments in this line?
-                // We can't just use lines[i].length because that's chars.
-                // We need to split the line again or iterate segments.
-                // Iterating segments is safer.
-                // Let's assume we iterate global segments until we hit a newline segment
-                let lineSegmentsCount = 0;
-                // Since rawValue.split('\n') consumes the newlines, we need to account for them.
-                // Alternative: iterate this.segments
-                // Find where the cursor falls.
-            }
             // Let's iterate segments to find cursor position (row, col)
             cursorLineIndex = 0;
-            let colIndex = 0; // Visual column or char index?
             // If we want visual cursor position, we need visual width of segments.
             let visualColIndex = 0;
             for (let i = 0; i < this.cursor; i++) {
@@ -77,11 +66,11 @@ class TextPrompt extends base_1.Prompt {
                     visualColIndex = 0;
                 }
                 else {
-                    if (this.options.isPassword) {
-                        visualColIndex += 1;
+                    if (maskChar !== undefined) {
+                        visualColIndex += maskChar.length;
                     }
                     else {
-                        visualColIndex += this.options.isPassword ? 1 : this.getSegmentWidth(seg);
+                        visualColIndex += this.getSegmentWidth(seg);
                     }
                 }
             }
@@ -90,7 +79,7 @@ class TextPrompt extends base_1.Prompt {
             // Now prepare lines for display (scrolling/truncation)
             // We need to reconstruct lines from segments to apply styling/truncation logic per line.
             let currentLineSegments = [];
-            let processedLines = []; // Array of segment arrays
+            const processedLines = []; // Array of segment arrays
             for (const seg of this.segments) {
                 if (seg === '\n') {
                     processedLines.push(currentLineSegments);
@@ -101,24 +90,16 @@ class TextPrompt extends base_1.Prompt {
                 }
             }
             processedLines.push(currentLineSegments); // Last line
-            processedLines.forEach((lineSegs, idx) => {
-                const isCursorLine = idx === cursorLineIndex;
-                const linePrefixLen = (idx === 0) ? prefixVisualLen : 0;
-                const maxContentLen = Math.max(10, cols - linePrefixLen - 1);
+            processedLines.forEach((lineSegs) => {
                 // Reconstruct line string for display calculation
                 // If password, join with *?
                 let visibleLine = '';
-                if (this.options.isPassword) {
-                    visibleLine = '*'.repeat(lineSegs.length);
+                if (maskChar !== undefined) {
+                    visibleLine = maskChar.repeat(lineSegs.length);
                 }
                 else {
                     visibleLine = lineSegs.join('');
                 }
-                // If this is cursor line, we need to handle horizontal scroll based on cursorRelativeCol.
-                // But cursorRelativeCol is global? No, we reset it on newline.
-                // So cursorRelativeCol above was correct for the current line.
-                if (isCursorLine) {
-                }
                 displayValueLines.push(theme_1.theme.main + visibleLine + ansi_1.ANSI.RESET);
             });
         }
@@ -145,6 +126,7 @@ class TextPrompt extends base_1.Prompt {
         if (linesUp > 0) {
             this.print(`\x1b[${linesUp}A`);
         }
+        this.lastLinesUp = linesUp;
         let targetCol = 0;
         if (cursorRelativeRow === 0) {
             targetCol = prefixVisualLen + cursorRelativeCol;

package/dist/prompts/toggle.d.ts

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

package/dist/prompts/toggle.js

@@ -10,7 +10,7 @@ class TogglePrompt extends base_1.Prompt {
         super(options);
         this.value = options.initial ?? false;
     }
-    render(firstRender) {
+    render(_firstRender) {
         const activeText = this.options.activeText || 'ON';
         const inactiveText = this.options.inactiveText || 'OFF';
         let toggleDisplay = '';

package/dist/prompts/transfer.d.ts

@@ -0,0 +1,18 @@
+import { Prompt } from '../base';
+import { TransferOptions, MouseEvent } from '../types';
+export declare class TransferPrompt<V> extends Prompt<[V[], V[]], TransferOptions<V>> {
+    private leftList;
+    private rightList;
+    private cursorLeft;
+    private cursorRight;
+    private scrollTopLeft;
+    private scrollTopRight;
+    private activeSide;
+    private readonly pageSize;
+    constructor(options: TransferOptions<V>);
+    private normalize;
+    protected truncate(str: string, width: number): string;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string): void;
+    protected handleMouse(event: MouseEvent): void;
+}