cli-menu-kit 0.1.0

package/dist/menu-multi.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * CLI Menu Kit - Multi Select Menu
+ * Interactive multi-select menu with checkboxes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectMultiMenu = selectMultiMenu;
+const components_1 = require("./components");
+const menu_core_1 = require("./menu-core");
+/**
+ * Interactive multi-select menu with checkboxes
+ *
+ * Features:
+ * - Arrow keys (↑/↓) to navigate
+ * - Space to toggle selection
+ * - A to select all
+ * - I to invert selection
+ * - Enter to confirm
+ * - Shows ◉ for selected items, ○ for unselected items
+ *
+ * @param options - Menu options
+ * @param config - Configuration object
+ * @returns Array of selected indices
+ */
+async function selectMultiMenu(options, config = {}) {
+    const { lang = 'zh', defaultSelected = [] } = config;
+    const inputPrompt = lang === 'zh'
+        ? `${components_1.symbols.success.color}${components_1.symbols.success.icon}${components_1.colors.reset} 空格选中/取消,回车确认: `
+        : `${components_1.symbols.success.color}${components_1.symbols.success.icon}${components_1.colors.reset} Space to toggle, Enter to confirm: `;
+    const hintText = (0, components_1.buildHint)(['arrows', 'space', 'all', 'invert', 'enter'], lang);
+    return new Promise((resolve) => {
+        let selectedIndex = 0;
+        let selectedItems = new Set(defaultSelected);
+        const state = (0, menu_core_1.setupTerminal)();
+        const cleanup = () => {
+            (0, menu_core_1.cleanupTerminal)(state, onKeyPress);
+            resolve(Array.from(selectedItems).sort((a, b) => a - b));
+        };
+        const render = () => {
+            let totalLines = 0;
+            // Move cursor up if not first render
+            (0, menu_core_1.moveCursorUp)(state);
+            // Render input line
+            process.stdout.write('\x1b[2K\r');
+            process.stdout.write(`${components_1.theme.muted}${inputPrompt}${components_1.colors.reset}`);
+            const selectedText = lang === 'zh' ? `${selectedItems.size} 项已选` : `${selectedItems.size} selected`;
+            process.stdout.write(`${components_1.theme.active}${selectedText}${components_1.colors.reset}`);
+            console.log();
+            console.log();
+            totalLines += 2;
+            // Render options with checkboxes
+            options.forEach((option, index) => {
+                const isCurrentLine = index === selectedIndex;
+                const isChecked = selectedItems.has(index);
+                const prefix = isCurrentLine ? `${components_1.theme.active}❯ ` : '  ';
+                const checkbox = isChecked ? `${components_1.theme.success}◉` : `${components_1.theme.muted}○`;
+                const textColor = isCurrentLine ? components_1.theme.active : (isChecked ? components_1.theme.title : components_1.colors.reset);
+                console.log(`${prefix}${checkbox} ${textColor}${option}${components_1.colors.reset}`);
+            });
+            totalLines += options.length;
+            // Render hints
+            totalLines += (0, menu_core_1.renderHints)(hintText);
+            state.renderedLines = totalLines;
+            state.isFirstRender = false;
+        };
+        const onKeyPress = (key) => {
+            // Handle vertical navigation
+            const newIndex = (0, menu_core_1.handleVerticalNavigation)(key, selectedIndex, options.length - 1);
+            if (newIndex !== null) {
+                selectedIndex = newIndex;
+                render();
+                return;
+            }
+            // Handle space (toggle selection)
+            if (key === ' ') {
+                if (selectedItems.has(selectedIndex)) {
+                    selectedItems.delete(selectedIndex);
+                }
+                else {
+                    selectedItems.add(selectedIndex);
+                }
+                render();
+                return;
+            }
+            // Handle 'A' (select all)
+            if (key.toUpperCase() === 'A') {
+                selectedItems.clear();
+                for (let i = 0; i < options.length; i++) {
+                    selectedItems.add(i);
+                }
+                render();
+                return;
+            }
+            // Handle 'I' (invert selection)
+            if (key.toUpperCase() === 'I') {
+                const newSelected = new Set();
+                for (let i = 0; i < options.length; i++) {
+                    if (!selectedItems.has(i)) {
+                        newSelected.add(i);
+                    }
+                }
+                selectedItems = newSelected;
+                render();
+                return;
+            }
+            // Handle Enter key
+            if (key === '\r') {
+                cleanup();
+                return;
+            }
+            // Handle Ctrl+C
+            if (key === '\u0003') {
+                (0, menu_core_1.exitWithGoodbye)(state, onKeyPress, () => (0, components_1.showGoodbye)(lang));
+            }
+        };
+        state.stdin.on('data', onKeyPress);
+        render();
+    });
+}

package/dist/menu-single.d.ts

@@ -0,0 +1,18 @@
+/**
+ * CLI Menu Kit - Single Select Menu
+ * Interactive menu selection with arrow keys and keyboard shortcuts
+ */
+import { MenuConfig, MenuOption } from './types';
+/**
+ * Interactive menu selection with BOTH arrow keys AND number input
+ *
+ * Features:
+ * - Arrow keys (↑/↓) to navigate with live highlight
+ * - Number/letter keys to directly jump and select
+ * - Enter key (⏎) to confirm selection
+ *
+ * @param options - Menu options (strings or objects with label/value)
+ * @param config - Configuration object
+ * @returns Selected index (0-based)
+ */
+export declare function selectMenu(options: Array<string | MenuOption>, config?: MenuConfig): Promise<number>;

package/dist/menu-single.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * CLI Menu Kit - Single Select Menu
+ * Interactive menu selection with arrow keys and keyboard shortcuts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectMenu = selectMenu;
+const components_1 = require("./components");
+const menu_core_1 = require("./menu-core");
+/**
+ * Interactive menu selection with BOTH arrow keys AND number input
+ *
+ * Features:
+ * - Arrow keys (↑/↓) to navigate with live highlight
+ * - Number/letter keys to directly jump and select
+ * - Enter key (⏎) to confirm selection
+ *
+ * @param options - Menu options (strings or objects with label/value)
+ * @param config - Configuration object
+ * @returns Selected index (0-based)
+ */
+async function selectMenu(options, config = {}) {
+    const { lang = 'zh', type = 'main', title, prompt, showPrompt = (type === 'main'), showHints = true } = config;
+    const inputPromptText = lang === 'zh'
+        ? '输入选项或用↑↓选择,回车确认: '
+        : 'Type option or use ↑↓ to select, Enter to confirm: ';
+    let hintKeys;
+    if (type === 'main') {
+        hintKeys = ['arrows', 'number', 'letter', 'enter'];
+    }
+    else if (type === 'firstRun') {
+        hintKeys = ['arrows', 'number', 'enter', 'esc'];
+    }
+    else {
+        hintKeys = ['arrows', 'number', 'enter'];
+    }
+    const hintText = showHints ? (0, components_1.buildHint)(hintKeys, lang) : '';
+    return new Promise((resolve) => {
+        let selectedIndex = 0;
+        const state = (0, menu_core_1.setupTerminal)();
+        const cleanup = (finalIndex) => {
+            (0, menu_core_1.cleanupTerminal)(state, onKeyPress);
+            resolve(finalIndex);
+        };
+        const render = () => {
+            let totalLines = 0;
+            // Move cursor up if not first render
+            (0, menu_core_1.moveCursorUp)(state);
+            // Render title
+            if (title) {
+                totalLines += (0, menu_core_1.renderHeader)(title);
+            }
+            // Render options
+            options.forEach((option, index) => {
+                (0, menu_core_1.renderSingleOption)(option, {
+                    index,
+                    isSelected: index === selectedIndex,
+                    showNumber: true
+                });
+            });
+            totalLines += options.length;
+            // Render input prompt with current selection value (BELOW options)
+            if (showPrompt) {
+                // Calculate display value (current selection number/letter)
+                let displayValue = '';
+                if (options[selectedIndex]) {
+                    const option = options[selectedIndex];
+                    if (typeof option === 'string') {
+                        displayValue = String(selectedIndex + 1);
+                    }
+                    else if (option.label) {
+                        const match = option.label.match(/^([^.]+)\./);
+                        if (match) {
+                            displayValue = match[1];
+                        }
+                        else {
+                            displayValue = String(selectedIndex + 1);
+                        }
+                    }
+                }
+                // Render prompt with display value
+                console.log();
+                process.stdout.write('\x1b[2K\r');
+                process.stdout.write(`  ${components_1.theme.muted}${inputPromptText}${components_1.colors.reset}`);
+                process.stdout.write(`${components_1.theme.active}${displayValue}${components_1.colors.reset}`);
+                console.log();
+                totalLines += 2;
+            }
+            // Render hints
+            if (showHints && hintText) {
+                totalLines += (0, menu_core_1.renderHints)(hintText);
+            }
+            state.renderedLines = totalLines;
+            state.isFirstRender = false;
+        };
+        const onKeyPress = (key) => {
+            // Handle vertical navigation
+            const newIndex = (0, menu_core_1.handleVerticalNavigation)(key, selectedIndex, options.length - 1);
+            if (newIndex !== null) {
+                selectedIndex = newIndex;
+                render();
+                return;
+            }
+            // Handle number input
+            const numIndex = (0, menu_core_1.handleNumberInput)(key, options.length);
+            if (numIndex !== null) {
+                selectedIndex = numIndex;
+                render();
+                return;
+            }
+            // Handle letter input
+            const letterIndex = (0, menu_core_1.handleLetterInput)(key, options);
+            if (letterIndex !== null) {
+                selectedIndex = letterIndex;
+                render();
+                return;
+            }
+            // Handle Enter key
+            if (key === '\r') {
+                cleanup(selectedIndex);
+                return;
+            }
+            // Handle Escape key (for firstRun type)
+            if (key === '\u001b' || key === '\u001b[') {
+                if (type === 'firstRun') {
+                    (0, menu_core_1.exitWithGoodbye)(state, onKeyPress, () => (0, components_1.showGoodbye)(lang));
+                }
+                return;
+            }
+            // Handle Ctrl+C
+            if (key === '\u0003') {
+                (0, menu_core_1.exitWithGoodbye)(state, onKeyPress, () => (0, components_1.showGoodbye)(lang));
+            }
+        };
+        state.stdin.on('data', onKeyPress);
+        render();
+    });
+}

package/dist/menu.d.ts

@@ -0,0 +1,66 @@
+/**
+ * CLI Menu Kit - Unified Menu Wrapper
+ * Convenient API for all menu types
+ */
+import { selectMenu } from './menu-single';
+import { selectMultiMenu } from './menu-multi';
+import { askYesNo, askInput, askNumber } from './input';
+import { MenuConfig, MenuOption, MultiSelectConfig } from './types';
+/**
+ * Unified menu interface
+ * Provides convenient access to all menu types
+ */
+export declare const menu: {
+    /**
+     * Single-select menu (vertical)
+     * @param options - Menu options
+     * @param config - Configuration
+     * @returns Selected index
+     */
+    select: typeof selectMenu;
+    /**
+     * Multi-select menu (vertical with checkboxes)
+     * @param options - Menu options
+     * @param config - Configuration
+     * @returns Array of selected indices
+     */
+    multiSelect: typeof selectMultiMenu;
+    /**
+     * Yes/No confirmation (horizontal single-select)
+     * @param prompt - Question to ask
+     * @param options - Configuration
+     * @returns true for Yes, false for No
+     */
+    confirm: typeof askYesNo;
+    /**
+     * Text input
+     * @param prompt - Input prompt
+     * @param options - Configuration with validation
+     * @returns User input string
+     */
+    input: typeof askInput;
+    /**
+     * Number input
+     * @param prompt - Input prompt
+     * @param options - Configuration with min/max
+     * @returns User input number
+     */
+    number: typeof askNumber;
+};
+/**
+ * Create a parent-child menu relationship
+ * Parent is single-select, child is multi-select
+ *
+ * @param parentOptions - Parent menu options
+ * @param getChildOptions - Function to get child options based on parent selection
+ * @param config - Configuration
+ * @returns Object with parentIndex and childIndices
+ */
+export declare function selectWithChildren(parentOptions: Array<string | MenuOption>, getChildOptions: (parentIndex: number) => string[], config?: {
+    parentConfig?: MenuConfig;
+    childConfig?: MultiSelectConfig;
+}): Promise<{
+    parentIndex: number;
+    childIndices: number[];
+}>;
+export { selectMenu, selectMultiMenu, askYesNo, askInput, askNumber };

package/dist/menu.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * CLI Menu Kit - Unified Menu Wrapper
+ * Convenient API for all menu types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askNumber = exports.askInput = exports.askYesNo = exports.selectMultiMenu = exports.selectMenu = exports.menu = void 0;
+exports.selectWithChildren = selectWithChildren;
+const menu_single_1 = require("./menu-single");
+Object.defineProperty(exports, "selectMenu", { enumerable: true, get: function () { return menu_single_1.selectMenu; } });
+const menu_multi_1 = require("./menu-multi");
+Object.defineProperty(exports, "selectMultiMenu", { enumerable: true, get: function () { return menu_multi_1.selectMultiMenu; } });
+const input_1 = require("./input");
+Object.defineProperty(exports, "askYesNo", { enumerable: true, get: function () { return input_1.askYesNo; } });
+Object.defineProperty(exports, "askInput", { enumerable: true, get: function () { return input_1.askInput; } });
+Object.defineProperty(exports, "askNumber", { enumerable: true, get: function () { return input_1.askNumber; } });
+/**
+ * Unified menu interface
+ * Provides convenient access to all menu types
+ */
+exports.menu = {
+    /**
+     * Single-select menu (vertical)
+     * @param options - Menu options
+     * @param config - Configuration
+     * @returns Selected index
+     */
+    select: menu_single_1.selectMenu,
+    /**
+     * Multi-select menu (vertical with checkboxes)
+     * @param options - Menu options
+     * @param config - Configuration
+     * @returns Array of selected indices
+     */
+    multiSelect: menu_multi_1.selectMultiMenu,
+    /**
+     * Yes/No confirmation (horizontal single-select)
+     * @param prompt - Question to ask
+     * @param options - Configuration
+     * @returns true for Yes, false for No
+     */
+    confirm: input_1.askYesNo,
+    /**
+     * Text input
+     * @param prompt - Input prompt
+     * @param options - Configuration with validation
+     * @returns User input string
+     */
+    input: input_1.askInput,
+    /**
+     * Number input
+     * @param prompt - Input prompt
+     * @param options - Configuration with min/max
+     * @returns User input number
+     */
+    number: input_1.askNumber
+};
+/**
+ * Create a parent-child menu relationship
+ * Parent is single-select, child is multi-select
+ *
+ * @param parentOptions - Parent menu options
+ * @param getChildOptions - Function to get child options based on parent selection
+ * @param config - Configuration
+ * @returns Object with parentIndex and childIndices
+ */
+async function selectWithChildren(parentOptions, getChildOptions, config = {}) {
+    // Show parent menu
+    const parentIndex = await (0, menu_single_1.selectMenu)(parentOptions, config.parentConfig);
+    // Get child options based on parent selection
+    const childOptions = getChildOptions(parentIndex);
+    // Show child menu if there are options
+    let childIndices = [];
+    if (childOptions.length > 0) {
+        childIndices = await (0, menu_multi_1.selectMultiMenu)(childOptions, config.childConfig);
+    }
+    return { parentIndex, childIndices };
+}

package/dist/types/display.types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Display component types for CLI Menu Kit
+ */
+/**
+ * Header types
+ */
+export type HeaderType = 'simple' | 'ascii';
+/**
+ * Simple header configuration
+ */
+export interface SimpleHeaderConfig {
+    text: string;
+    color?: string;
+}
+/**
+ * ASCII header configuration
+ */
+export interface AsciiHeaderConfig {
+    asciiArt: string;
+    subtitle?: string;
+    version?: string;
+    url?: string;
+    borderChar?: string;
+}
+/**
+ * Progress indicator configuration
+ */
+export interface ProgressConfig {
+    steps: string[];
+    currentStep: number;
+    separator?: string;
+}
+/**
+ * Message types
+ */
+export type MessageType = 'success' | 'error' | 'warning' | 'info' | 'question';
+/**
+ * Message configuration
+ */
+export interface MessageConfig {
+    type: MessageType;
+    message: string;
+}
+/**
+ * Summary table configuration
+ */
+export interface SummaryTableConfig {
+    title?: string;
+    sections: Array<{
+        header?: string;
+        items: Array<{
+            key: string;
+            value: string;
+        }>;
+    }>;
+    width?: number;
+}

package/dist/types/display.types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Display component types for CLI Menu Kit
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/input.types.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Input component types for CLI Menu Kit
+ */
+/**
+ * Base input configuration
+ */
+export interface BaseInputConfig {
+    /** Input prompt text */
+    prompt: string;
+    /** Default value */
+    defaultValue?: string;
+    /** Validation function */
+    validate?: (value: string) => boolean | string;
+    /** Error message for validation failure */
+    errorMessage?: string;
+    /** Goodbye message function */
+    onExit?: () => void;
+}
+/**
+ * Text input configuration
+ */
+export interface TextInputConfig extends BaseInputConfig {
+    /** Placeholder text */
+    placeholder?: string;
+    /** Maximum length */
+    maxLength?: number;
+    /** Minimum length */
+    minLength?: number;
+    /** Allow empty input */
+    allowEmpty?: boolean;
+}
+/**
+ * Number input configuration
+ */
+export interface NumberInputConfig extends BaseInputConfig {
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Allow decimals */
+    allowDecimals?: boolean;
+    /** Allow negative numbers */
+    allowNegative?: boolean;
+}
+/**
+ * Language selector configuration
+ */
+export interface LanguageSelectorConfig {
+    /** Available languages */
+    languages: Array<{
+        code: string;
+        name: string;
+        nativeName?: string;
+    }>;
+    /** Default language code */
+    defaultLanguage?: string;
+    /** Prompt text */
+    prompt?: string;
+    /** Goodbye message function */
+    onExit?: () => void;
+}
+/**
+ * Modify field configuration
+ */
+export interface ModifyFieldConfig {
+    /** Field name */
+    fieldName: string;
+    /** Current value */
+    currentValue: string;
+    /** Prompt for modification */
+    modifyPrompt?: string;
+    /** Prompt for new value */
+    newValuePrompt?: string;
+    /** Validation function */
+    validate?: (value: string) => boolean | string;
+    /** Goodbye message function */
+    onExit?: () => void;
+}
+/**
+ * Input result types
+ */
+export type TextInputResult = string;
+export type NumberInputResult = number;
+export type LanguageSelectorResult = string;
+export interface ModifyFieldResult {
+    modified: boolean;
+    value: string;
+}

package/dist/types/input.types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Input component types for CLI Menu Kit
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/layout.types.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Layout system types for CLI Menu Kit
+ * Defines how components are composed and rendered
+ */
+/**
+ * Layout element types that can be arranged
+ */
+export type LayoutElement = 'header' | 'options' | 'input' | 'hints' | 'progress';
+/**
+ * Visibility configuration for layout elements
+ */
+export interface LayoutVisibility {
+    header?: boolean;
+    input?: boolean;
+    hints?: boolean;
+    progress?: boolean;
+}
+/**
+ * Spacing configuration for layout elements
+ * Values represent number of blank lines
+ */
+export interface LayoutSpacing {
+    beforeHeader?: number;
+    afterHeader?: number;
+    beforeOptions?: number;
+    afterOptions?: number;
+    beforeInput?: number;
+    afterInput?: number;
+    beforeHints?: number;
+    beforeProgress?: number;
+    afterProgress?: number;
+}
+/**
+ * Complete menu layout configuration
+ */
+export interface MenuLayout {
+    /** Order in which elements are rendered */
+    order: LayoutElement[];
+    /** Which elements are visible */
+    visible: LayoutVisibility;
+    /** Spacing between elements */
+    spacing?: LayoutSpacing;
+}
+/**
+ * Preset layout configurations
+ */
+export declare const LAYOUT_PRESETS: {
+    /** Main menu with header */
+    MAIN_MENU: MenuLayout;
+    /** Sub menu without header */
+    SUB_MENU: MenuLayout;
+    /** Wizard step with progress indicator */
+    WIZARD_STEP: MenuLayout;
+    /** Minimal layout (options only) */
+    MINIMAL: MenuLayout;
+};

package/dist/types/layout.types.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Layout system types for CLI Menu Kit
+ * Defines how components are composed and rendered
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAYOUT_PRESETS = void 0;
+/**
+ * Preset layout configurations
+ */
+exports.LAYOUT_PRESETS = {
+    /** Main menu with header */
+    MAIN_MENU: {
+        order: ['header', 'options', 'input', 'hints'],
+        visible: { header: true, input: true, hints: true },
+        spacing: { afterHeader: 1, afterOptions: 1, beforeHints: 1 }
+    },
+    /** Sub menu without header */
+    SUB_MENU: {
+        order: ['options', 'input', 'hints'],
+        visible: { header: false, input: true, hints: true },
+        spacing: { afterOptions: 1, beforeHints: 1 }
+    },
+    /** Wizard step with progress indicator */
+    WIZARD_STEP: {
+        order: ['header', 'progress', 'options', 'input', 'hints'],
+        visible: { header: true, progress: true, input: true, hints: true },
+        spacing: { afterHeader: 1, afterProgress: 1, afterOptions: 1, beforeHints: 1 }
+    },
+    /** Minimal layout (options only) */
+    MINIMAL: {
+        order: ['options'],
+        visible: { header: false, input: false, hints: false },
+        spacing: {}
+    }
+};