mepcli 1.0.0-beta.5 → 1.0.0-rc.1

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 CodeTease
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025 CodeTease
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -14,7 +14,7 @@ A **CodeTease** project.
 ## Features
 
 - **Zero Dependency:** Keeps your project clean and fast.
-- **Comprehensive:** 60+ prompt types for every need.
+- **Comprehensive:** 70+ prompt types for every need.
 - **Mouse Support:** Built-in scroll and click interaction.
 - **Responsive:** Fluid cursor movement and validation.
 - **Elegant:** Modern ANSI color styling.
@@ -85,9 +85,11 @@ Powerful tools for selecting dates, files, colors, and more.
 | `checkbox` | Multiple choice selection. |
 | `multiSelect` | Multiple selection with filtering. |
 | `multiColumnSelect` | Selection with grid layout. |
+| `fuzzyMultiColumn` | Grid layout + Fuzzy search combination. |
 | `fuzzySelect` | Selection with fuzzy search. |
 | `autocomplete` | Async searchable selection. |
 | `selectRange` | Select a continuous range (start-end). |
+| `multiRange` | Select multiple discontinuous ranges. |
 | `treeSelect` | Hierarchical multi-selection. |
 | `grid` | 2D matrix selection (rows x columns). |
 | `seat` | Seat selection map with gaps. |
@@ -98,6 +100,7 @@ Powerful tools for selecting dates, files, colors, and more.
 | `time` | Time picker. |
 | `file` | File system navigator. |
 | `breadcrumb` | Breadcrumb navigation style. |
+| `breadcrumbSearch` | Breadcrumb navigation with local fuzzy search. |
 | `miller` | Miller columns navigation. |
 | `tree` | Hierarchical tree navigation. |
 
@@ -501,12 +504,23 @@ The Grid prompt (Matrix selection) includes robust shortcuts for bulk actions.
 </details>
 
 <details>
-<summary><b>Select Range Prompt</b></summary>
+<summary><b>Select Range Prompt & Multi Range Prompt</b></summary>
 
 *   **Keyboard:**
     *   `Arrows (Up/Down)`: Navigate items.
-    *   `Space`: Set/Unset anchor point.
-    *   `Enter`: Submit selected range.
+    *   `Space`: Set/Unset anchor point (drag start) or commit range (drag end).
+    *   `Enter`: Submit selected range(s).
+
+</details>
+
+<details>
+<summary><b>Breadcrumb Search Prompt</b></summary>
+
+*   **Keyboard:**
+    *   `Arrows`: Navigate.
+    *   `Typing`: Enter **Search Mode** (filters current folder).
+    *   `Esc`: Exit Search Mode.
+    *   `Enter`: Drill down (Folder) or Select (File).
 
 </details>
 

package/dist/core.d.ts

@@ -109,4 +109,7 @@ export declare class MepCLI {
     static connectionString(options: ConnectionStringOptions): Promise<ConnectionStringResult>;
     static curl(options: CurlOptions): Promise<CurlResult>;
     static phone(options: PhoneOptions): Promise<string>;
+    static fuzzyMultiColumn<V>(options: MultiColumnSelectOptions<V>): Promise<V>;
+    static multiRange<V>(options: SelectRangeOptions<V>): Promise<V[]>;
+    static breadcrumbSearch(options: BreadcrumbOptions): Promise<string>;
 }

package/dist/core.js

@@ -71,6 +71,9 @@ const license_1 = require("./prompts/license");
 const regex_1 = require("./prompts/regex");
 const box_1 = require("./prompts/box");
 const phone_1 = require("./prompts/phone");
+const fuzzy_multi_column_1 = require("./prompts/fuzzy-multi-column");
+const multi_range_1 = require("./prompts/multi-range");
+const breadcrumb_search_1 = require("./prompts/breadcrumb-search");
 const connection_string_1 = require("./prompts/connection-string");
 const curl_1 = require("./prompts/curl");
 const pipeline_1 = require("./pipeline");
@@ -322,6 +325,15 @@ class MepCLI {
     static phone(options) {
         return new phone_1.PhonePrompt(options).run();
     }
+    static fuzzyMultiColumn(options) {
+        return new fuzzy_multi_column_1.FuzzyMultiColumnPrompt(options).run();
+    }
+    static multiRange(options) {
+        return new multi_range_1.MultiRangePrompt(options).run();
+    }
+    static breadcrumbSearch(options) {
+        return new breadcrumb_search_1.BreadcrumbSearchPrompt(options).run();
+    }
 }
 exports.MepCLI = MepCLI;
 MepCLI.theme = theme_1.theme;

package/dist/index.d.ts

@@ -41,5 +41,8 @@ export * from './prompts/box';
 export * from './prompts/connection-string';
 export * from './prompts/curl';
 export * from './prompts/phone';
+export * from './prompts/fuzzy-multi-column';
+export * from './prompts/multi-range';
+export * from './prompts/breadcrumb-search';
 export * from './pipeline';
 export * from './tasks';

package/dist/index.js

@@ -57,5 +57,8 @@ __exportStar(require("./prompts/box"), exports);
 __exportStar(require("./prompts/connection-string"), exports);
 __exportStar(require("./prompts/curl"), exports);
 __exportStar(require("./prompts/phone"), exports);
+__exportStar(require("./prompts/fuzzy-multi-column"), exports);
+__exportStar(require("./prompts/multi-range"), exports);
+__exportStar(require("./prompts/breadcrumb-search"), exports);
 __exportStar(require("./pipeline"), exports);
 __exportStar(require("./tasks"), exports);

package/dist/prompts/breadcrumb-search.d.ts

@@ -0,0 +1,13 @@
+import { BreadcrumbPrompt } from './breadcrumb';
+import { BreadcrumbOptions } from '../types';
+export declare class BreadcrumbSearchPrompt extends BreadcrumbPrompt {
+    private isSearchMode;
+    private searchBuffer;
+    private filteredEntries;
+    private searchCursor;
+    constructor(options: BreadcrumbOptions);
+    protected handleInput(char: string, key: Buffer): void;
+    private updateSearchResults;
+    protected render(firstRender: boolean): void;
+    private highlight;
+}

package/dist/prompts/breadcrumb-search.js

@@ -0,0 +1,226 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BreadcrumbSearchPrompt = void 0;
+const breadcrumb_1 = require("./breadcrumb");
+const theme_1 = require("../theme");
+const ansi_1 = require("../ansi");
+const symbols_1 = require("../symbols");
+const utils_1 = require("../utils");
+const path = __importStar(require("path"));
+class BreadcrumbSearchPrompt extends breadcrumb_1.BreadcrumbPrompt {
+    constructor(options) {
+        super(options);
+        this.isSearchMode = false;
+        this.searchBuffer = '';
+        this.filteredEntries = [];
+        this.searchCursor = 0;
+    }
+    handleInput(char, key) {
+        if (this.isLoading)
+            return;
+        // Toggle Search Mode or Type
+        if (!this.isSearchMode) {
+            // If typing a regular char, enter search mode
+            if (char.length === 1 && !/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+                this.isSearchMode = true;
+                this.searchBuffer = char;
+                this.updateSearchResults();
+                this.render(false);
+                return;
+            }
+            // Otherwise use default navigation
+            super.handleInput(char, key);
+            return;
+        }
+        // --- In Search Mode ---
+        // Esc: Exit search mode
+        if (char === '\x1b') {
+            this.isSearchMode = false;
+            this.searchBuffer = '';
+            this.render(false);
+            return;
+        }
+        // Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            if (this.searchBuffer.length > 0) {
+                this.searchBuffer = this.searchBuffer.slice(0, -1);
+                if (this.searchBuffer.length === 0) {
+                    this.isSearchMode = false;
+                }
+                else {
+                    this.updateSearchResults();
+                }
+                this.render(false);
+            }
+            else {
+                this.isSearchMode = false;
+                this.render(false);
+            }
+            return;
+        }
+        // Enter
+        if (char === '\r' || char === '\n') {
+            if (this.filteredEntries.length === 0)
+                return;
+            const entry = this.filteredEntries[this.searchCursor];
+            if (entry.isDirectory) {
+                // Drill down
+                // Hack: Find index in currentEntries
+                const realIndex = this.currentEntries.findIndex(e => e.name === entry.name);
+                if (realIndex !== -1) {
+                    this.cursor = realIndex;
+                    this.drillDown().then(() => {
+                        this.isSearchMode = false;
+                        this.searchBuffer = '';
+                    });
+                }
+            }
+            else {
+                const fullPath = path.join(this.currentPath, entry.name);
+                this.submit(fullPath);
+            }
+            return;
+        }
+        // Navigation (Up/Down)
+        if (this.isUp(char)) {
+            if (this.searchCursor > 0) {
+                this.searchCursor--;
+            }
+            else {
+                this.searchCursor = Math.max(0, this.filteredEntries.length - 1);
+            }
+            this.render(false);
+            return;
+        }
+        if (this.isDown(char)) {
+            if (this.searchCursor < this.filteredEntries.length - 1) {
+                this.searchCursor++;
+            }
+            else {
+                this.searchCursor = 0;
+            }
+            this.render(false);
+            return;
+        }
+        // Typing
+        if (char.length === 1 && !/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            this.searchBuffer += char;
+            this.updateSearchResults();
+            this.render(false);
+        }
+    }
+    updateSearchResults() {
+        if (!this.searchBuffer) {
+            this.filteredEntries = [];
+            return;
+        }
+        const results = this.currentEntries.map(entry => {
+            const match = (0, utils_1.fuzzyMatch)(this.searchBuffer, entry.name);
+            return { entry, match };
+        }).filter(item => item.match !== null)
+            .sort((a, b) => b.match.score - a.match.score);
+        this.filteredEntries = results.map(r => ({
+            ...r.entry,
+            _match: r.match
+        }));
+        this.searchCursor = 0;
+    }
+    render(firstRender) {
+        if (!this.isSearchMode) {
+            super.render(firstRender);
+            return;
+        }
+        // Render Search Overlay
+        let output = '';
+        // Breadcrumb + Search Bar
+        const relative = path.relative(this.root, this.currentPath);
+        // ... (Truncation logic omitted for brevity, simplified version)
+        const pathStr = relative || path.basename(this.root);
+        const prefix = `${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} `;
+        output += `${prefix}${theme_1.theme.muted}${pathStr}/${ansi_1.ANSI.RESET} ${ansi_1.ANSI.FG_YELLOW}(Search: ${this.searchBuffer})${ansi_1.ANSI.RESET}\n`;
+        if (this.filteredEntries.length === 0) {
+            output += `  ${theme_1.theme.muted}No results found${ansi_1.ANSI.RESET}`;
+        }
+        else {
+            const pageSize = this.pageSize;
+            let start = 0;
+            const half = Math.floor(pageSize / 2);
+            start = Math.max(0, this.searchCursor - half);
+            if (start + pageSize > this.filteredEntries.length) {
+                start = Math.max(0, this.filteredEntries.length - pageSize);
+            }
+            const visible = this.filteredEntries.slice(start, start + pageSize);
+            visible.forEach((entry, index) => {
+                const actualIndex = start + index;
+                const isSelected = actualIndex === this.searchCursor;
+                const icon = entry.isDirectory ? '📂' : '📄';
+                // Highlight match
+                const title = this.highlight(entry.name, entry._match.indices, isSelected);
+                let line = '';
+                if (isSelected) {
+                    line += `${theme_1.theme.main}${symbols_1.symbols.pointer} ${icon} ${title}${ansi_1.ANSI.RESET}`;
+                }
+                else {
+                    line += `  ${icon} ${title}`;
+                }
+                if (index > 0 || index === 0)
+                    output += line;
+                if (index < visible.length - 1)
+                    output += '\n';
+            });
+        }
+        this.renderFrame(output);
+    }
+    highlight(text, indices, isSelected) {
+        let output = '';
+        const indexSet = new Set(indices);
+        for (let i = 0; i < text.length; i++) {
+            if (indexSet.has(i)) {
+                if (isSelected) {
+                    output += `${ansi_1.ANSI.BOLD}${ansi_1.ANSI.FG_WHITE}${text[i]}${theme_1.theme.main}`;
+                }
+                else {
+                    output += `${ansi_1.ANSI.BOLD}${ansi_1.ANSI.FG_CYAN}${text[i]}${ansi_1.ANSI.RESET}`;
+                }
+            }
+            else {
+                output += text[i];
+            }
+        }
+        return output;
+    }
+}
+exports.BreadcrumbSearchPrompt = BreadcrumbSearchPrompt;

package/dist/prompts/breadcrumb.d.ts

@@ -1,22 +1,32 @@
 import { Prompt } from '../base';
 import { BreadcrumbOptions, MouseEvent } from '../types';
+interface StackItem {
+    path: string;
+    cursor: number;
+    scrollTop: number;
+}
+interface DirEntry {
+    name: string;
+    isDirectory: boolean;
+}
 export declare class BreadcrumbPrompt extends Prompt<string, BreadcrumbOptions> {
-    private stack;
-    private currentEntries;
-    private cursor;
-    private scrollTop;
-    private root;
-    private currentPath;
-    private separator;
-    private showHidden;
-    private isLoading;
-    private error;
-    private readonly pageSize;
+    protected stack: StackItem[];
+    protected currentEntries: DirEntry[];
+    protected cursor: number;
+    protected scrollTop: number;
+    protected root: string;
+    protected currentPath: string;
+    protected separator: string;
+    protected showHidden: boolean;
+    protected isLoading: boolean;
+    protected error: string | null;
+    protected readonly pageSize: number;
     constructor(options: BreadcrumbOptions);
-    private loadDirectory;
-    private drillDown;
-    private goUp;
+    protected loadDirectory(dir: string): Promise<void>;
+    protected drillDown(): Promise<void>;
+    protected goUp(): Promise<void>;
     protected render(_firstRender: boolean): void;
     protected handleInput(char: string, _key: Buffer): void;
     protected handleMouse(_event: MouseEvent): void;
 }
+export {};

package/dist/prompts/fuzzy-multi-column.d.ts

@@ -0,0 +1,12 @@
+import { MultiColumnSelectPrompt } from './multi-column-select';
+import { MultiColumnSelectOptions } from '../types';
+export declare class FuzzyMultiColumnPrompt<V> extends MultiColumnSelectPrompt<V> {
+    private filteredResults;
+    private debounceTimer;
+    constructor(options: MultiColumnSelectOptions<V>);
+    protected getFilteredChoices(): any[];
+    protected handleInput(char: string): void;
+    private performSearch;
+    private highlight;
+    protected render(_firstRender: boolean): void;
+}

package/dist/prompts/fuzzy-multi-column.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FuzzyMultiColumnPrompt = void 0;
+const multi_column_select_1 = require("./multi-column-select");
+const theme_1 = require("../theme");
+const ansi_1 = require("../ansi");
+const utils_1 = require("../utils");
+const symbols_1 = require("../symbols");
+class FuzzyMultiColumnPrompt extends multi_column_select_1.MultiColumnSelectPrompt {
+    constructor(options) {
+        super(options);
+        this.filteredResults = [];
+        this.filteredResults = this.options.choices;
+    }
+    getFilteredChoices() {
+        return this.filteredResults || this.options.choices;
+    }
+    handleInput(char) {
+        // Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            if (this.searchBuffer.length > 0) {
+                this.searchBuffer = this.searchBuffer.slice(0, -1);
+                this.performSearch();
+            }
+            return;
+        }
+        // Intercept typing to add debounce
+        if (char.length === 1 && !/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            this.searchBuffer += char;
+            // Check if debounce is needed
+            if (this.options.choices.length > 1000) {
+                if (this.debounceTimer)
+                    clearTimeout(this.debounceTimer);
+                this.debounceTimer = setTimeout(() => {
+                    this.performSearch();
+                }, 150); // 150ms debounce
+            }
+            else {
+                this.performSearch();
+            }
+            return;
+        }
+        super.handleInput(char);
+    }
+    performSearch() {
+        if (!this.searchBuffer) {
+            this.filteredResults = this.options.choices;
+        }
+        else {
+            const results = this.options.choices.map(c => {
+                if (this.isSeparator(c))
+                    return null;
+                const match = (0, utils_1.fuzzyMatch)(this.searchBuffer, c.title);
+                return { choice: c, match };
+            }).filter(item => item && item.match !== null)
+                // Sort by score descending
+                .sort((a, b) => b.match.score - a.match.score);
+            this.filteredResults = results.map(r => {
+                r.choice._match = r.match;
+                return r.choice;
+            });
+        }
+        this.selectedIndex = 0;
+        this.render(false);
+    }
+    highlight(text, indices, isSelected) {
+        let output = '';
+        const indexSet = new Set(indices);
+        for (let i = 0; i < text.length; i++) {
+            if (indexSet.has(i)) {
+                if (isSelected) {
+                    output += `${ansi_1.ANSI.BOLD}${ansi_1.ANSI.FG_WHITE}${text[i]}${theme_1.theme.main}`; // Reset to main theme
+                }
+                else {
+                    output += `${ansi_1.ANSI.BOLD}${ansi_1.ANSI.FG_CYAN}${text[i]}${ansi_1.ANSI.RESET}`;
+                }
+            }
+            else {
+                output += text[i];
+            }
+        }
+        return output;
+    }
+    render(_firstRender) {
+        let output = '';
+        const choices = this.getFilteredChoices();
+        // Header
+        const searchStr = this.searchBuffer ? ` ${theme_1.theme.muted}(Fuzzy: ${this.searchBuffer})${ansi_1.ANSI.RESET}` : '';
+        output += `${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}${searchStr}\n`;
+        if (choices.length === 0) {
+            output += `  ${theme_1.theme.muted}No results found${ansi_1.ANSI.RESET}`;
+            this.renderFrame(output);
+            return;
+        }
+        // Grid Render
+        const totalRows = Math.ceil(choices.length / this.cols);
+        // Adjust Scroll
+        const currentRow = Math.floor(this.selectedIndex / this.cols);
+        if (currentRow < this.scrollTop) {
+            this.scrollTop = currentRow;
+        }
+        else if (currentRow >= this.scrollTop + this.pageSize) {
+            this.scrollTop = currentRow - this.pageSize + 1;
+        }
+        // Edge case: if list shrinks
+        if (this.scrollTop > totalRows - 1) {
+            this.scrollTop = Math.max(0, totalRows - this.pageSize);
+        }
+        const startRow = this.scrollTop;
+        const endRow = Math.min(totalRows, startRow + this.pageSize);
+        for (let r = startRow; r < endRow; r++) {
+            let rowStr = '';
+            for (let c = 0; c < this.cols; c++) {
+                const idx = r * this.cols + c;
+                if (idx >= choices.length)
+                    break;
+                const choice = choices[idx];
+                // Truncate if needed
+                let title = choice.title || '';
+                if ((0, utils_1.stringWidth)(title) > this.colWidth - 3) {
+                    title = title.slice(0, this.colWidth - 4) + '…';
+                }
+                const match = choice._match;
+                const isSelected = idx === this.selectedIndex;
+                if (match && this.searchBuffer) {
+                    title = this.highlight(title, match.indices, isSelected);
+                }
+                let cellContent = '';
+                if (isSelected) {
+                    cellContent = `${theme_1.theme.main}${symbols_1.symbols.pointer} ${title}${ansi_1.ANSI.RESET}`;
+                }
+                else {
+                    cellContent = `  ${title}`;
+                }
+                // Pad cell to colWidth
+                const currentWidth = (0, utils_1.stringWidth)(this.stripAnsi(cellContent));
+                const padding = Math.max(0, this.colWidth - currentWidth);
+                // Add cell to row
+                rowStr += cellContent + ' '.repeat(padding);
+            }
+            output += rowStr + '\n';
+        }
+        // Remove trailing newline
+        if (output.endsWith('\n'))
+            output = output.slice(0, -1);
+        this.renderFrame(output);
+    }
+}
+exports.FuzzyMultiColumnPrompt = FuzzyMultiColumnPrompt;

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

@@ -1,8 +1,8 @@
 import { SelectPrompt } from './select';
 import { MultiColumnSelectOptions } from '../types';
 export declare class MultiColumnSelectPrompt<V> extends SelectPrompt<V, MultiColumnSelectOptions<V>> {
-    private cols;
-    private colWidth;
+    protected cols: number;
+    protected colWidth: number;
     constructor(options: MultiColumnSelectOptions<V>);
     private calculateLayout;
     protected render(_firstRender: boolean): void;

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

@@ -0,0 +1,9 @@
+import { SelectRangePrompt } from './select-range';
+import { SelectRangeOptions } from '../types';
+export declare class MultiRangePrompt<V> extends SelectRangePrompt<V> {
+    private committedRanges;
+    constructor(options: SelectRangeOptions<V>);
+    private mergeRanges;
+    protected handleInput(char: string, key?: Buffer): void;
+    protected render(_firstRender: boolean): void;
+}

package/dist/prompts/multi-range.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiRangePrompt = void 0;
+const select_range_1 = require("./select-range");
+const theme_1 = require("../theme");
+const ansi_1 = require("../ansi");
+const symbols_1 = require("../symbols");
+class MultiRangePrompt extends select_range_1.SelectRangePrompt {
+    constructor(options) {
+        super(options);
+        this.committedRanges = [];
+    }
+    mergeRanges() {
+        if (this.committedRanges.length === 0)
+            return;
+        // Sort by start index
+        this.committedRanges.sort((a, b) => a.start - b.start);
+        const merged = [];
+        let current = this.committedRanges[0];
+        for (let i = 1; i < this.committedRanges.length; i++) {
+            const next = this.committedRanges[i];
+            if (current.end >= next.start - 1) { // Overlap or adjacent
+                current.end = Math.max(current.end, next.end);
+            }
+            else {
+                merged.push(current);
+                current = next;
+            }
+        }
+        merged.push(current);
+        this.committedRanges = merged;
+    }
+    handleInput(char, key) {
+        // Handle Enter (Submit)
+        if (char === '\r' || char === '\n') {
+            const choices = this.getFilteredChoices();
+            if (choices.length === 0)
+                return;
+            // If user was dragging, commit that range first
+            if (this.anchorIndex !== null) {
+                const start = Math.min(this.anchorIndex, this.selectedIndex);
+                const end = Math.max(this.anchorIndex, this.selectedIndex);
+                this.committedRanges.push({ start, end });
+                this.mergeRanges();
+                this.anchorIndex = null;
+            }
+            // Collect all indices from committed ranges
+            const allIndices = new Set();
+            for (const range of this.committedRanges) {
+                for (let i = range.start; i <= range.end; i++) {
+                    allIndices.add(i);
+                }
+            }
+            if (allIndices.size === 0) {
+                allIndices.add(this.selectedIndex);
+            }
+            const selectedItems = [];
+            const sortedIndices = Array.from(allIndices).sort((a, b) => a - b);
+            for (const idx of sortedIndices) {
+                if (idx < choices.length) {
+                    const choice = choices[idx];
+                    if (!this.isSeparator(choice)) {
+                        selectedItems.push(choice.value);
+                    }
+                }
+            }
+            this.submit(selectedItems);
+            return;
+        }
+        // Handle Space (Anchor/Commit)
+        if (char === ' ') {
+            if (this.anchorIndex === null) {
+                // Start dragging
+                this.anchorIndex = this.selectedIndex;
+            }
+            else {
+                // Commit range
+                const start = Math.min(this.anchorIndex, this.selectedIndex);
+                const end = Math.max(this.anchorIndex, this.selectedIndex);
+                this.committedRanges.push({ start, end });
+                this.mergeRanges();
+                this.anchorIndex = null;
+            }
+            this.render(false);
+            return;
+        }
+        super.handleInput(char, key);
+    }
+    render(_firstRender) {
+        let output = '';
+        const choices = this.getFilteredChoices();
+        // Scroll Logic (inherited from SelectPrompt basically, but good to ensure)
+        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.scrollTop > choices.length - 1) {
+            this.scrollTop = Math.max(0, choices.length - this.pageSize);
+        }
+        // Header
+        const searchStr = this.searchBuffer ? ` ${theme_1.theme.muted}(Filter: ${this.searchBuffer})${ansi_1.ANSI.RESET}` : '';
+        output += `${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}${searchStr}\n`;
+        if (choices.length === 0) {
+            output += `  ${theme_1.theme.muted}No results found${ansi_1.ANSI.RESET}`;
+        }
+        else {
+            const visibleChoices = choices.slice(this.scrollTop, this.scrollTop + this.pageSize);
+            visibleChoices.forEach((choice, index) => {
+                const actualIndex = this.scrollTop + index;
+                if (index > 0)
+                    output += '\n';
+                let isCommitted = false;
+                for (const range of this.committedRanges) {
+                    if (actualIndex >= range.start && actualIndex <= range.end) {
+                        isCommitted = true;
+                        break;
+                    }
+                }
+                let isDragging = false;
+                if (this.anchorIndex !== null) {
+                    const min = Math.min(this.anchorIndex, this.selectedIndex);
+                    const max = Math.max(this.anchorIndex, this.selectedIndex);
+                    if (actualIndex >= min && actualIndex <= max) {
+                        isDragging = true;
+                    }
+                }
+                if (this.isSeparator(choice)) {
+                    output += `  ${ansi_1.ANSI.DIM}${choice.text || symbols_1.symbols.line.repeat(8)}${ansi_1.ANSI.RESET}`;
+                }
+                else {
+                    let prefix = '  ';
+                    const title = choice.title;
+                    let content = title;
+                    // Markers
+                    if (actualIndex === this.anchorIndex) {
+                        prefix = `${theme_1.theme.muted}> ${ansi_1.ANSI.RESET}`;
+                    }
+                    if (actualIndex === this.selectedIndex) {
+                        prefix = `${theme_1.theme.main}${symbols_1.symbols.pointer} `;
+                    }
+                    if (actualIndex === this.selectedIndex && actualIndex === this.anchorIndex) {
+                        prefix = `${theme_1.theme.main}${symbols_1.symbols.pointer}>`;
+                    }
+                    // Highlighting
+                    if (isCommitted || isDragging) {
+                        // Apply highlighting style
+                        // If committed, maybe green? If dragging, maybe yellow or just highlighted?
+                        if (actualIndex !== this.selectedIndex && actualIndex !== this.anchorIndex) {
+                            prefix = `${theme_1.theme.success}* ${ansi_1.ANSI.RESET}`;
+                        }
+                        content = `${theme_1.theme.success}${title}${ansi_1.ANSI.RESET}`;
+                        if (isDragging && !isCommitted) {
+                            // Distinguish dragging visual? Maybe dim? 
+                            // Using same style as single range prompt for consistency
+                        }
+                    }
+                    // Cursor Underline
+                    if (actualIndex === this.selectedIndex) {
+                        content = `${ansi_1.ANSI.UNDERLINE}${content}${ansi_1.ANSI.RESET}`;
+                    }
+                    output += `${prefix}${content}`;
+                }
+            });
+        }
+        output += `\n${theme_1.theme.muted}(Space to anchor/commit, Enter to submit)${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+}
+exports.MultiRangePrompt = MultiRangePrompt;

package/dist/prompts/phone.js

@@ -49,8 +49,6 @@ class PhonePrompt extends base_1.Prompt {
                 if (mask[i] === '#') {
                     return i;
                 }
-                else {
-                }
             }
             if (mask[i] === '#') {
                 rawCounter++;
@@ -164,7 +162,7 @@ class PhonePrompt extends base_1.Prompt {
         }
         // Input Section
         const formatted = this.renderFormattedNumber();
-        let inputRender = formatted;
+        const inputRender = formatted;
         // Layout: [Prefix] [Input]
         const line = `${prefixRender} ${inputRender}`;
         let output = title + line;
@@ -255,8 +253,6 @@ class PhonePrompt extends base_1.Prompt {
                     this.activeSection = 'country';
                 }
             }
-            else {
-            }
             this.render(false);
             return;
         }

package/package.json

@@ -1,51 +1,51 @@
-{
-  "name": "mepcli",
-  "version": "1.0.0-beta.5",
-  "description": "Zero-dependency, interactive CLI prompt for Node.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/CodeTease/mep.git"
-  },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build",
-    "test": "jest",
-    "demo": "ts-node example.ts",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix"
-  },
-  "keywords": [
-    "cli",
-    "prompt",
-    "inquirer",
-    "enquirer",
-    "interactive",
-    "zero-dependency",
-    "codetease",
-    "command-line",
-    "typescript",
-    "color",
-    "ansi"
-  ],
-  "author": "CodeTease",
-  "license": "MIT",
-  "devDependencies": {
-    "@eslint/js": "^9",
-    "@types/jest": "^30",
-    "@types/node": "^22",
-    "eslint": "^9",
-    "globals": "^17",
-    "jest": "^30",
-    "ts-jest": "^29",
-    "ts-node": "^10",
-    "typescript": "^5",
-    "typescript-eslint": "^8"
-  }
-}
+{
+  "name": "mepcli",
+  "version": "1.0.0-rc.1",
+  "description": "Zero-dependency, interactive CLI prompt for Node.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CodeTease/mep.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "jest",
+    "demo": "ts-node example.ts",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "keywords": [
+    "cli",
+    "prompt",
+    "inquirer",
+    "enquirer",
+    "interactive",
+    "zero-dependency",
+    "codetease",
+    "command-line",
+    "typescript",
+    "color",
+    "ansi"
+  ],
+  "author": "CodeTease",
+  "license": "MIT",
+  "devDependencies": {
+    "@eslint/js": "^9",
+    "@types/jest": "^30",
+    "@types/node": "^22",
+    "eslint": "^9",
+    "globals": "^17",
+    "jest": "^30",
+    "ts-jest": "^29",
+    "ts-node": "^10",
+    "typescript": "^5",
+    "typescript-eslint": "^8"
+  }
+}