mepcli 0.6.0 → 0.6.1

package/dist/base.d.ts

@@ -2,8 +2,7 @@ import { MouseEvent } from './types';
 import { detectCapabilities } from './utils';
 /**
  * Abstract base class for all prompts.
- * Handles common logic like stdin management, raw mode, and cleanup
- * to enforce DRY (Don't Repeat Yourself) principles.
+ * Implements a Robust Linear Scan Diffing Engine.
  */
 export declare abstract class Prompt<T, O> {
     protected options: O;
@@ -15,48 +14,20 @@ export declare abstract class Prompt<T, O> {
     private _inputParser;
     private _onKeyHandler?;
     private _onDataHandler?;
-    protected lastRenderHeight: number;
     protected lastRenderLines: string[];
+    protected lastRenderHeight: number;
     protected capabilities: ReturnType<typeof detectCapabilities>;
     constructor(options: O);
-    /**
-     * Renders the UI. Must be implemented by subclasses.
-     * @param firstRender Indicates if this is the initial render.
-     */
     protected abstract render(firstRender: boolean): void;
-    /**
-     * Handles specific key inputs. Must be implemented by subclasses.
-     * @param char The string representation of the key.
-     * @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.
-     * Sets up raw mode and listeners, returning a Promise.
-     */
     run(): Promise<T>;
-    /**
-     * Cleans up listeners and restores stdin state.
-     */
     protected cleanup(): void;
-    /**
-     * Submits the final value and resolves the promise.
-     */
     protected submit(result: T): void;
     /**
-     * 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).
+     * Renders the frame using a linear scan diffing algorithm.
+     * Prevents flicker and handles height changes (expand/collapse) robustly.
      */
     protected renderFrame(content: string): void;
     protected stripAnsi(str: string): string;

package/dist/base.js

@@ -6,32 +6,22 @@ const input_1 = require("./input");
 const utils_1 = require("./utils");
 /**
  * Abstract base class for all prompts.
- * Handles common logic like stdin management, raw mode, and cleanup
- * to enforce DRY (Don't Repeat Yourself) principles.
+ * Implements a Robust Linear Scan Diffing Engine.
  */
 class Prompt {
     constructor(options) {
-        // Smart Cursor State
-        this.lastRenderHeight = 0;
         this.lastRenderLines = [];
+        this.lastRenderHeight = 0;
         this.options = options;
         this.stdin = process.stdin;
         this.stdout = process.stdout;
         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);
     }
-    /**
-     * Starts the prompt interaction.
-     * Sets up raw mode and listeners, returning a Promise.
-     */
     run() {
         return new Promise((resolve, reject) => {
             this._resolve = resolve;
@@ -41,24 +31,15 @@ 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) {
-                // In CI, maybe don't hide cursor or do nothing?
-                // But for now follow standard flow.
-            }
             this.print(ansi_1.ANSI.HIDE_CURSOR);
+            // Initial render
             this.render(true);
-            // Setup Input Parser Listeners
             this._onKeyHandler = (char, buffer) => {
-                // Global Exit Handler (Ctrl+C)
-                if (char === '\u0003') {
+                if (char === '\u0003') { // Ctrl+C
                     this.cleanup();
                     this.print(ansi_1.ANSI.SHOW_CURSOR + '\n');
                     if (this._reject)
@@ -68,7 +49,6 @@ class Prompt {
                 this.handleInput(char, buffer);
             };
             this._inputParser.on('keypress', this._onKeyHandler);
-            // Listen to mouse events
             this._inputParser.on('mouse', (event) => {
                 this.handleMouse(event);
             });
@@ -78,9 +58,6 @@ class Prompt {
             this.stdin.on('data', this._onDataHandler);
         });
     }
-    /**
-     * Cleans up listeners and restores stdin state.
-     */
     cleanup() {
         if (this._onDataHandler) {
             this.stdin.removeListener('data', this._onDataHandler);
@@ -88,7 +65,6 @@ class Prompt {
         if (this._onKeyHandler) {
             this._inputParser.removeListener('keypress', this._onKeyHandler);
         }
-        // Disable Mouse Tracking
         this.print(ansi_1.ANSI.DISABLE_MOUSE);
         if (typeof this.stdin.setRawMode === 'function') {
             this.stdin.setRawMode(false);
@@ -96,51 +72,74 @@ class Prompt {
         this.stdin.pause();
         this.print(ansi_1.ANSI.SHOW_CURSOR);
     }
-    /**
-     * Submits the final value and resolves the promise.
-     */
     submit(result) {
         this.cleanup();
         this.print('\n');
         if (this._resolve)
             this._resolve(result);
     }
-    // --- Rendering Utilities ---
-    /**
-     * 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).
+     * Renders the frame using a linear scan diffing algorithm.
+     * Prevents flicker and handles height changes (expand/collapse) robustly.
      */
     renderFrame(content) {
         const width = this.stdout.columns || 80;
         const rawLines = content.split('\n');
-        // Truncate each line to fit terminal width to avoid wrapping issues
+        // Truncate lines to prevent wrapping artifacts
         const newLines = rawLines.map(line => this.truncate(line, width));
-        // 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) {
-            // If the previous render had multiple lines, move up to the first line
-            if (this.lastRenderHeight > 1) {
-                this.print(`\x1b[${this.lastRenderHeight - 1}A`);
-            }
+        // 1. First Render Case
+        if (this.lastRenderLines.length === 0) {
+            this.print(newLines.join('\n'));
+            this.lastRenderLines = newLines;
+            this.lastRenderHeight = newLines.length;
+            return;
+        }
+        let outputBuffer = '';
+        // 2. Return Cursor to the Top of the Prompt
+        if (this.lastRenderHeight > 1) {
+            outputBuffer += `\x1b[${this.lastRenderHeight - 1}A`;
         }
-        // 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
+        outputBuffer += '\r'; // Ensure column 0
+        // 3. Linear Scan & Update
         for (let i = 0; i < newLines.length; i++) {
-            this.print(newLines[i]);
-            // Add newline character between lines, but not after the last line
-            if (i < newLines.length - 1) {
-                this.print('\n');
+            const newLine = newLines[i];
+            // Logic for moving to the next line
+            if (i > 0) {
+                if (i < this.lastRenderLines.length) {
+                    // Moving within the previously existing area.
+                    // Use 'Down' (B) to avoid scrolling/shifting existing content.
+                    outputBuffer += '\x1b[B\r';
+                }
+                else {
+                    // Moving into NEW area (Append).
+                    // Must use '\n' to create the new line.
+                    outputBuffer += '\n';
+                }
+            }
+            // Printing logic
+            if (i < this.lastRenderLines.length) {
+                const oldLine = this.lastRenderLines[i];
+                if (newLine !== oldLine) {
+                    // Overwrite existing line
+                    outputBuffer += ansi_1.ANSI.ERASE_LINE + newLine;
+                }
+            }
+            else {
+                // Print new line (we are already at start due to '\n' above)
+                outputBuffer += newLine;
             }
         }
-        // 5. Update state for the next render cycle
+        // 4. Handle Shrinkage (Clear garbage below)
+        if (newLines.length < this.lastRenderLines.length) {
+            // Move down to the first obsolete line
+            outputBuffer += '\n';
+            // Clear everything below
+            outputBuffer += ansi_1.ANSI.ERASE_DOWN;
+            // Move back up to the last valid line to maintain cursor state consistency
+            outputBuffer += `\x1b[A`;
+        }
+        this.print(outputBuffer);
+        // Update State
         this.lastRenderLines = newLines;
         this.lastRenderHeight = newLines.length;
     }
@@ -152,51 +151,28 @@ class Prompt {
         if (visualWidth <= width) {
             return str;
         }
-        // Heuristic truncation using stringWidth
-        // We iterate and sum width until we hit limit - 3
         let currentWidth = 0;
         let cutIndex = 0;
         let inAnsi = false;
         for (let i = 0; i < str.length; i++) {
-            const code = str.charCodeAt(i);
-            if (str[i] === '\x1b') {
+            if (str[i] === '\x1b')
                 inAnsi = true;
-            }
-            if (inAnsi) {
-                if ((str[i] >= '@' && str[i] <= '~') || (str[i] >= 'a' && str[i] <= 'z') || (str[i] >= 'A' && str[i] <= 'Z')) {
-                    inAnsi = false;
-                }
-            }
-            else {
-                // Re-implement basic width logic here for the cut index finding
-                let charWidth = 1;
-                let cp = code;
-                if (code >= 0xD800 && code <= 0xDBFF && i + 1 < str.length) {
-                    const next = str.charCodeAt(i + 1);
-                    if (next >= 0xDC00 && next <= 0xDFFF) {
-                        cp = (code - 0xD800) * 0x400 + (next - 0xDC00) + 0x10000;
-                        // i is incremented in main loop but we need to skip next char
-                        // We'll handle i increment in the loop
-                    }
-                }
-                if (cp >= 0x1100) { // Quick check for potentially wide
-                    // It's acceptable to be slightly aggressive on wide chars for truncation
-                    charWidth = 2;
-                }
+            if (!inAnsi) {
+                const code = str.charCodeAt(i);
+                const charWidth = code > 255 ? 2 : 1;
                 if (currentWidth + charWidth > width - 3) {
-                    cutIndex = i;
                     break;
                 }
                 currentWidth += charWidth;
-                if (cp > 0xFFFF) {
-                    i++; // Skip low surrogate
-                }
+            }
+            else {
+                if (str[i] === 'm' || (str[i] >= 'A' && str[i] <= 'Z'))
+                    inAnsi = false;
             }
             cutIndex = i + 1;
         }
         return str.substring(0, cutIndex) + '...' + ansi_1.ANSI.RESET;
     }
-    // Helper to check for arrow keys including application mode
     isUp(char) {
         return char === '\u001b[A' || char === '\u001bOA';
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mepcli",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Zero-dependency, interactive CLI prompt for Node.js",
   "repository": {
     "type": "git",