mepcli 0.5.0 → 0.6.0

package/dist/prompts/tree.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreePrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+class TreePrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.cursor = 0;
+        this.expandedNodes = new Set();
+        this.flatList = [];
+        this.scrollTop = 0;
+        this.pageSize = 15;
+        // Icons
+        this.ICON_CLOSED = symbols_1.symbols.pointer === '>' ? '+' : '▸';
+        this.ICON_OPEN = symbols_1.symbols.pointer === '>' ? '-' : '▾';
+        this.initializeExpanded(this.options.data);
+        if (this.options.initial !== undefined) {
+            this.expandPathTo(this.options.initial);
+        }
+        this.recalculateFlatList();
+        if (this.options.initial !== undefined) {
+            const index = this.flatList.findIndex(item => item.node.value === this.options.initial);
+            if (index !== -1) {
+                this.cursor = index;
+            }
+        }
+    }
+    expandPathTo(value) {
+        const find = (nodes) => {
+            for (const node of nodes) {
+                if (node.value === value)
+                    return true;
+                if (node.children) {
+                    if (find(node.children)) {
+                        this.expandedNodes.add(node);
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+        find(this.options.data);
+    }
+    initializeExpanded(nodes) {
+        for (const node of nodes) {
+            if (node.expanded) {
+                this.expandedNodes.add(node);
+            }
+            if (node.children) {
+                this.initializeExpanded(node.children);
+            }
+        }
+    }
+    recalculateFlatList() {
+        this.flatList = [];
+        this.traverse(this.options.data, 0, null);
+        if (this.cursor >= this.flatList.length) {
+            this.cursor = Math.max(0, this.flatList.length - 1);
+        }
+    }
+    traverse(nodes, depth, parent) {
+        for (const node of nodes) {
+            this.flatList.push({
+                node,
+                depth,
+                parent
+            });
+            if (node.children && node.children.length > 0 && this.expandedNodes.has(node)) {
+                this.traverse(node.children, depth + 1, node);
+            }
+        }
+    }
+    toggleRecursive(node, expand) {
+        if (expand)
+            this.expandedNodes.add(node);
+        else
+            this.expandedNodes.delete(node);
+        if (node.children) {
+            node.children.forEach(child => this.toggleRecursive(child, expand));
+        }
+    }
+    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.flatList.length === 0) {
+            output += `  ${theme_1.theme.muted}No data${ansi_1.ANSI.RESET}`;
+            this.renderFrame(output);
+            return;
+        }
+        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((item, index) => {
+            const actualIndex = this.scrollTop + index;
+            const isSelected = actualIndex === this.cursor;
+            const indentSize = this.options.indent || 2;
+            const indentation = ' '.repeat(item.depth * indentSize);
+            let linePrefix = '';
+            if (isSelected) {
+                linePrefix = `${theme_1.theme.main}${symbols_1.symbols.pointer} `;
+            }
+            else {
+                linePrefix = '  ';
+            }
+            let icon = '  ';
+            const hasChildren = item.node.children && item.node.children.length > 0;
+            if (hasChildren) {
+                if (this.expandedNodes.has(item.node)) {
+                    icon = `${this.ICON_OPEN} `;
+                }
+                else {
+                    icon = `${this.ICON_CLOSED} `;
+                }
+            }
+            let title = item.node.title;
+            if (item.node.disabled) {
+                title = `${theme_1.theme.muted}${title} (disabled)${ansi_1.ANSI.RESET}`;
+            }
+            let line = `${indentation}${icon}${title}`;
+            if (isSelected) {
+                line = `${theme_1.theme.main}${line}${ansi_1.ANSI.RESET}`;
+            }
+            output += linePrefix + line;
+            if (index < visible.length - 1)
+                output += '\n';
+        });
+        output += `\n${theme_1.theme.muted}(Arrows: Nav, e: Expand All, c: Collapse All)${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+    handleInput(char, _key) {
+        if (this.flatList.length === 0)
+            return;
+        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;
+        }
+        const currentItem = this.flatList[this.cursor];
+        const node = currentItem.node;
+        const hasChildren = node.children && node.children.length > 0;
+        // Recursive Expand (e)
+        if (char === 'e' && hasChildren) {
+            this.toggleRecursive(node, true);
+            this.recalculateFlatList();
+            this.render(false);
+            return;
+        }
+        // Recursive Collapse (c)
+        if (char === 'c' && hasChildren) {
+            this.toggleRecursive(node, false);
+            this.recalculateFlatList();
+            this.render(false);
+            return;
+        }
+        if (this.isRight(char)) {
+            if (hasChildren) {
+                if (!this.expandedNodes.has(node)) {
+                    this.expandedNodes.add(node);
+                    this.recalculateFlatList();
+                }
+                else {
+                    if (this.cursor + 1 < this.flatList.length) {
+                        this.cursor++;
+                    }
+                }
+                this.render(false);
+                return;
+            }
+        }
+        if (this.isLeft(char)) {
+            if (hasChildren && this.expandedNodes.has(node)) {
+                this.expandedNodes.delete(node);
+                this.recalculateFlatList();
+                this.render(false);
+                return;
+            }
+            else {
+                if (currentItem.parent) {
+                    const parentIndex = this.flatList.findIndex(x => x.node === currentItem.parent);
+                    if (parentIndex !== -1) {
+                        this.cursor = parentIndex;
+                        this.render(false);
+                        return;
+                    }
+                }
+            }
+        }
+        if (char === ' ') {
+            if (hasChildren) {
+                if (this.expandedNodes.has(node)) {
+                    this.expandedNodes.delete(node);
+                }
+                else {
+                    this.expandedNodes.add(node);
+                }
+                this.recalculateFlatList();
+                this.render(false);
+            }
+            return;
+        }
+        if (char === '\r' || char === '\n') {
+            if (!node.disabled) {
+                this.submit(node.value);
+            }
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll') {
+            if (event.scroll === 'up') {
+                this.cursor = (this.cursor - 1 + this.flatList.length) % this.flatList.length;
+                this.render(false);
+            }
+            else if (event.scroll === 'down') {
+                this.cursor = (this.cursor + 1) % this.flatList.length;
+                this.render(false);
+            }
+        }
+    }
+}
+exports.TreePrompt = TreePrompt;

package/dist/prompts/wait.d.ts

@@ -0,0 +1,18 @@
+import { Prompt } from '../base';
+import { BaseOptions } from '../types';
+interface WaitOptions extends BaseOptions {
+    seconds: number;
+    autoSubmit?: boolean;
+}
+export declare class WaitPrompt extends Prompt<void, WaitOptions> {
+    private remaining;
+    private timer?;
+    private isDone;
+    constructor(options: WaitOptions);
+    run(): Promise<void>;
+    private stopTimer;
+    protected cleanup(): void;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string): void;
+}
+export {};

package/dist/prompts/wait.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaitPrompt = void 0;
+// src/prompts/wait.ts
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+class WaitPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.isDone = false;
+        this.remaining = options.seconds;
+    }
+    run() {
+        // Start the countdown immediately upon running
+        this.timer = setInterval(() => {
+            this.remaining--;
+            if (this.remaining <= 0) {
+                this.isDone = true;
+                this.stopTimer();
+                if (this.options.autoSubmit) {
+                    this.submit();
+                }
+                else {
+                    this.render(false);
+                }
+            }
+            else {
+                this.render(false);
+            }
+        }, 1000);
+        return super.run();
+    }
+    stopTimer() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+    }
+    cleanup() {
+        this.stopTimer();
+        super.cleanup();
+    }
+    render(_firstRender) {
+        let output = `${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} `;
+        if (this.isDone) {
+            output += `${theme_1.theme.success}Done! Press Enter to continue.${ansi_1.ANSI.RESET}`;
+        }
+        else {
+            // Fun countdown visualization
+            output += `${theme_1.theme.muted}Please wait... ${this.remaining}s${ansi_1.ANSI.RESET}`;
+        }
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        if (this.isDone && (char === '\r' || char === '\n')) {
+            this.submit();
+        }
+        // Else: Ignore all input while waiting
+    }
+}
+exports.WaitPrompt = WaitPrompt;

package/dist/types.d.ts

@@ -19,6 +19,9 @@ export interface MouseEvent {
     button: number;
     action: 'press' | 'release' | 'move' | 'scroll';
     scroll?: 'up' | 'down';
+    shift?: boolean;
+    ctrl?: boolean;
+    meta?: boolean;
 }
 export interface TextOptions extends BaseOptions {
     placeholder?: string;
@@ -26,6 +29,7 @@ export interface TextOptions extends BaseOptions {
     validate?: (value: string) => string | boolean | Promise<string | boolean>;
     isPassword?: boolean;
     multiline?: boolean;
+    mask?: string;
 }
 export interface Separator {
     separator: true;
@@ -39,6 +43,14 @@ export interface SelectChoice<V> {
 export interface SelectOptions<V> extends BaseOptions {
     choices: (SelectChoice<V> | Separator)[];
 }
+export interface TransferOptions<V> extends BaseOptions {
+    source: (string | SelectChoice<V>)[];
+    target?: (string | SelectChoice<V>)[];
+}
+export interface CronOptions extends BaseOptions {
+    initial?: string;
+    placeholder?: string;
+}
 export interface CheckboxChoice<V> extends SelectChoice<V> {
     selected?: boolean;
 }
@@ -74,6 +86,13 @@ export interface SliderOptions extends BaseOptions {
     step?: number;
     unit?: string;
 }
+export interface RangeOptions extends BaseOptions {
+    min: number;
+    max: number;
+    initial?: [number, number];
+    step?: number;
+    unit?: string;
+}
 export interface RatingOptions extends BaseOptions {
     min?: number;
     max?: number;
@@ -100,6 +119,11 @@ export interface AutocompleteOptions<V> extends BaseOptions {
 export interface SortOptions extends BaseOptions {
     items: string[];
 }
+export interface EditorOptions extends BaseOptions {
+    initial?: string;
+    extension?: string;
+    waitUserInput?: boolean;
+}
 export interface TableRow<V> {
     value: V;
     row: string[];
@@ -109,3 +133,84 @@ export interface TableOptions<V> extends BaseOptions {
     data: TableRow<V>[];
     rows?: number;
 }
+export interface TreeNode<V> {
+    title: string;
+    value: V;
+    children?: TreeNode<V>[];
+    expanded?: boolean;
+    disabled?: boolean;
+    selected?: boolean | 'indeterminate';
+}
+export interface TreeOptions<V> extends BaseOptions {
+    data: TreeNode<V>[];
+    initial?: V;
+    indent?: number;
+}
+export interface KeypressOptions extends BaseOptions {
+    keys?: string[];
+    showInvisible?: boolean;
+}
+export interface FormField {
+    name: string;
+    message: string;
+    initial?: string;
+    validate?: (value: string) => string | boolean | Promise<string | boolean>;
+}
+export interface FormOptions extends BaseOptions {
+    fields: FormField[];
+}
+export interface SnippetOptions extends BaseOptions {
+    template: string;
+    values?: Record<string, string>;
+    fields?: Record<string, {
+        message?: string;
+        validate?: (value: string) => string | boolean;
+    }>;
+}
+export interface SpamOptions extends BaseOptions {
+    threshold: number;
+    spamKey?: string;
+    decay?: boolean;
+}
+export interface WaitOptions extends BaseOptions {
+    seconds: number;
+    autoSubmit?: boolean;
+}
+export interface CodeOptions extends BaseOptions {
+    template: string;
+    language?: 'json' | 'yaml';
+    /**
+     * Enable syntax highlighting (Experimental).
+     * @default true
+     */
+    highlight?: boolean;
+}
+export interface TreeSelectNode<V> {
+    title: string;
+    value: V;
+    children?: TreeSelectNode<V>[];
+    expanded?: boolean;
+    disabled?: boolean;
+    selected?: boolean | 'indeterminate';
+}
+export interface TreeSelectOptions<V> extends BaseOptions {
+    data: TreeSelectNode<V>[];
+    initial?: V[];
+    indent?: number;
+}
+export interface ColorOptions extends BaseOptions {
+    initial?: string;
+    format?: 'hex' | 'rgb' | 'hsl';
+}
+export interface GridOptions extends BaseOptions {
+    rows: string[];
+    columns: string[];
+    initial?: boolean[][];
+}
+export interface CalendarOptions extends BaseOptions {
+    mode?: 'single' | 'range';
+    initial?: Date | [Date, Date];
+    min?: Date;
+    max?: Date;
+    weekStart?: 0 | 1;
+}

package/dist/utils.js

@@ -13,7 +13,7 @@ function detectCapabilities() {
     // Check for CI
     const isCI = !!env.CI;
     // Check for True Color support
-    const hasTrueColor = env.COLORTERM === 'truecolor';
+    const hasTrueColor = env.COLORTERM === 'truecolor' || !!env.WT_SESSION;
     // Check if it is a TTY
     const isTTY = process.stdout.isTTY;
     const isWindows = process.platform === 'win32';
@@ -131,7 +131,11 @@ function stringWidth(str) {
             continue;
         }
         if (inAnsi) {
-            if ((str[i] >= '@' && str[i] <= '~') || (str[i] >= 'a' && str[i] <= 'z') || (str[i] >= 'A' && str[i] <= 'Z')) {
+            if (str[i] === '[') {
+                // Continue, this is the start of CSI
+                continue;
+            }
+            if ((str[i] >= '@' && str[i] <= '~')) {
                 inAnsi = false;
             }
             continue;