cli-menu-kit 0.1.26 → 0.2.1

package/dist/components/menus/radio-menu.js

@@ -5,61 +5,47 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.showRadioMenu = showRadioMenu;
-const layout_types_js_1 = require("../../types/layout.types.js");
 const terminal_js_1 = require("../../core/terminal.js");
 const keyboard_js_1 = require("../../core/keyboard.js");
 const renderer_js_1 = require("../../core/renderer.js");
+const renderer_js_2 = require("../../core/renderer.js");
 const colors_js_1 = require("../../core/colors.js");
 const registry_js_1 = require("../../i18n/registry.js");
-/**
- * Generate hints based on menu configuration and actual options
- */
-function generateHints(options, allowNumberKeys, allowLetterKeys) {
-    const hints = [];
-    // Count selectable options
-    const selectableCount = options.filter(opt => !(typeof opt === 'object' && 'type' in opt && opt.type === 'separator')).length;
-    // Only show arrow hints if there are multiple options
-    if (selectableCount > 1) {
-        hints.push((0, registry_js_1.t)('hints.arrows'));
+function buildSectionLabelText(label, width) {
+    if (!label) {
+        return '';
     }
-    // Check if there are actually number-prefixed options
-    if (allowNumberKeys) {
-        const hasNumberOptions = options.some(opt => {
-            if (typeof opt === 'string') {
-                return /^\d+\./.test(opt);
-            }
-            return false;
-        });
-        if (hasNumberOptions) {
-            hints.push((0, registry_js_1.t)('hints.numbers'));
-        }
+    const labelWithPadding = ` ${label} `;
+    const dashesTotal = Math.max(0, width - labelWithPadding.length);
+    const dashesLeft = Math.floor(dashesTotal / 2);
+    const dashesRight = dashesTotal - dashesLeft;
+    return `  ${'─'.repeat(dashesLeft)}${labelWithPadding}${'─'.repeat(dashesRight)}`;
+}
+function buildOptionRenderText(text, isHighlighted, prefix) {
+    const parts = text.split(' - ');
+    const mainText = parts[0] || '';
+    const description = parts.length > 1 ? parts.slice(1).join(' - ') : '';
+    let line = isHighlighted ? '❯ ' : '  ';
+    if (prefix) {
+        line += prefix;
     }
-    // Check if there are actually letter-prefixed options
-    if (allowLetterKeys) {
-        const hasLetterOptions = options.some(opt => {
-            if (typeof opt === 'string') {
-                return /^[a-zA-Z]\./.test(opt);
-            }
-            return false;
-        });
-        if (hasLetterOptions) {
-            hints.push((0, registry_js_1.t)('hints.letters'));
-        }
+    line += mainText;
+    if (description) {
+        line += ` - ${description}`;
     }
-    hints.push((0, registry_js_1.t)('hints.enter'));
-    return hints;
+    return line;
 }
 /**
  * Show a radio menu (single-select)
  * @param config - Menu configuration
+ * @param hints - Optional hints to display at the bottom (for Page Layout use)
  * @returns Promise resolving to selected option
  */
-async function showRadioMenu(config) {
-    const { options, title, prompt, hints, layout = layout_types_js_1.LAYOUT_PRESETS.MAIN_MENU, defaultIndex = 0, allowNumberKeys = true, allowLetterKeys = false, separatorWidth = 30, onExit, preserveOnSelect = false } = config;
+async function showRadioMenu(config, hints) {
+    const { options, title, prompt, defaultIndex = 0, allowNumberKeys = true, allowLetterKeys = false, separatorWidth = 30, onExit, preserveOnSelect = false } = config;
+    const preserveOnExit = config.preserveOnExit ?? preserveOnSelect;
     // Use i18n for default prompt if not provided
     const displayPrompt = prompt || (0, registry_js_1.t)('menus.selectPrompt');
-    // Generate hints dynamically if not provided
-    const displayHints = hints || generateHints(options, allowNumberKeys, allowLetterKeys);
     // Validate options
     if (!options || options.length === 0) {
         throw new Error('RadioMenu requires at least one option');
@@ -72,25 +58,27 @@ async function showRadioMenu(config) {
     const optionData = [];
     options.forEach((opt, index) => {
         if (typeof opt === 'object' && 'type' in opt && opt.type === 'separator') {
-            optionData.push({ value: '', isSeparator: true, label: opt.label });
+            optionData.push({ display: '', value: '', isSeparator: true, label: opt.label });
         }
         else {
+            let display;
             let value;
             if (typeof opt === 'string') {
+                display = opt;
                 value = opt;
             }
             else if ('value' in opt) {
+                display = opt.label ?? String(opt.value ?? '');
                 value = opt.value ?? opt.label ?? '';
             }
             else {
+                display = opt.label ?? '';
                 value = opt.label ?? '';
             }
-            optionData.push({ value, isSeparator: false });
+            optionData.push({ display, value, isSeparator: false });
             selectableIndices.push(index);
         }
     });
-    // Use MINIMAL layout for single-option menus
-    const effectiveLayout = selectableIndices.length === 1 ? layout_types_js_1.LAYOUT_PRESETS.MINIMAL : layout;
     // Ensure selectedIndex points to a selectable option
     if (!selectableIndices.includes(selectedIndex)) {
         selectedIndex = selectableIndices[0] || 0;
@@ -115,80 +103,71 @@ async function showRadioMenu(config) {
     const render = () => {
         (0, terminal_js_1.clearMenu)(state);
         let lineCount = 0;
-        // Render based on layout order
-        effectiveLayout.order.forEach(element => {
-            // Add spacing before element
-            const spacingKey = `before${element.charAt(0).toUpperCase() + element.slice(1)}`;
-            if (effectiveLayout.spacing?.[spacingKey]) {
-                (0, renderer_js_1.renderBlankLines)(effectiveLayout.spacing[spacingKey]);
-                lineCount += effectiveLayout.spacing[spacingKey];
-            }
-            switch (element) {
-                case 'header':
-                    if (effectiveLayout.visible.header && title) {
-                        (0, renderer_js_1.renderHeader)(`  ${title}`, colors_js_1.colors.cyan);
-                        lineCount++;
-                    }
-                    break;
-                case 'options':
-                    optionData.forEach((item, index) => {
-                        if (item.isSeparator) {
-                            // Render section label with configured width
-                            (0, renderer_js_1.renderSectionLabel)(item.label, separatorWidth);
-                        }
-                        else {
-                            // Check if option starts with a number or letter prefix
-                            const numberMatch = item.value.match(/^(\d+)\.\s*/);
-                            const letterMatch = item.value.match(/^([a-zA-Z])\.\s*/);
-                            // Don't add prefix if option already has number or letter prefix
-                            const prefix = (numberMatch || letterMatch) ? '' : `${selectableIndices.indexOf(index) + 1}. `;
-                            // Check if this is an Exit option (contains "Exit" or "Quit")
-                            const isExitOption = /\b(exit|quit)\b/i.test(item.value);
-                            const displayValue = isExitOption ? `${colors_js_1.uiColors.error}${item.value}${colors_js_1.colors.reset}` : item.value;
-                            // For radio menus, don't show selection indicator (pass undefined instead of false)
-                            (0, renderer_js_1.renderOption)(displayValue, undefined, index === selectedIndex, prefix);
-                            // Add blank line after last item before next separator
-                            const nextIndex = index + 1;
-                            if (nextIndex < optionData.length && optionData[nextIndex].isSeparator) {
-                                (0, terminal_js_1.writeLine)('');
-                                lineCount++; // Count the blank line
-                            }
-                        }
-                        lineCount++;
-                    });
-                    break;
-                case 'input':
-                    if (effectiveLayout.visible.input) {
-                        // Calculate display value (current selection number)
-                        let displayValue = '';
-                        const currentItem = optionData[selectedIndex];
-                        if (currentItem && !currentItem.isSeparator) {
-                            const match = currentItem.value.match(/^([^.]+)\./);
-                            if (match) {
-                                displayValue = match[1];
-                            }
-                            else {
-                                displayValue = String(selectableIndices.indexOf(selectedIndex) + 1);
-                            }
-                        }
-                        (0, renderer_js_1.renderInputPrompt)(displayPrompt, displayValue);
-                        lineCount++;
-                    }
-                    break;
-                case 'hints':
-                    if (effectiveLayout.visible.hints && displayHints.length > 0) {
-                        (0, renderer_js_1.renderHints)(displayHints);
-                        lineCount++;
-                    }
-                    break;
+        const addVisualLines = (text) => {
+            lineCount += (0, terminal_js_1.countVisualLines)(text);
+        };
+        // Render title if provided
+        if (title) {
+            (0, renderer_js_1.renderHeader)(`  ${title}`, colors_js_1.uiColors.primary);
+            addVisualLines(`  ${title}`);
+            (0, renderer_js_1.renderBlankLines)(1);
+            addVisualLines('');
+        }
+        // Render options
+        optionData.forEach((item, index) => {
+            if (item.isSeparator) {
+                // Render section label with configured width
+                (0, renderer_js_1.renderSectionLabel)(item.label, separatorWidth);
+                addVisualLines(buildSectionLabelText(item.label, separatorWidth));
             }
-            // Add spacing after element
-            const afterSpacingKey = `after${element.charAt(0).toUpperCase() + element.slice(1)}`;
-            if (effectiveLayout.spacing?.[afterSpacingKey]) {
-                (0, renderer_js_1.renderBlankLines)(effectiveLayout.spacing[afterSpacingKey]);
-                lineCount += effectiveLayout.spacing[afterSpacingKey];
+            else {
+                // Check if option starts with a number or letter prefix
+                const numberMatch = item.display.match(/^(\d+)\.\s*/);
+                const letterMatch = item.display.match(/^([a-zA-Z])\.\s*/);
+                // Don't add prefix if option already has number or letter prefix
+                const prefix = (numberMatch || letterMatch) ? '' : `${selectableIndices.indexOf(index) + 1}. `;
+                // Check if this is an Exit option (contains "Exit", "Quit", or Chinese "退出")
+                // Keep unselected exit entries in error color, but let selected row use normal highlight style.
+                const isExitOption = /\b(exit|quit)\b|退出/i.test(item.display);
+                const isCurrent = index === selectedIndex;
+                const displayValue = isExitOption && !isCurrent
+                    ? `${colors_js_1.uiColors.error}${item.display}${colors_js_1.colors.reset}`
+                    : item.display;
+                // For radio menus, don't show selection indicator (pass undefined instead of false)
+                (0, renderer_js_1.renderOption)(displayValue, undefined, isCurrent, prefix);
+                addVisualLines(buildOptionRenderText(displayValue, isCurrent, prefix));
+                // Add blank line after last item before next separator
+                const nextIndex = index + 1;
+                if (nextIndex < optionData.length && optionData[nextIndex].isSeparator) {
+                    (0, terminal_js_1.writeLine)('');
+                    addVisualLines('');
+                }
             }
         });
+        // Render input prompt
+        (0, renderer_js_1.renderBlankLines)(1);
+        addVisualLines('');
+        // Calculate display value (current selection number)
+        let displayValue = '';
+        const currentItem = optionData[selectedIndex];
+        if (currentItem && !currentItem.isSeparator) {
+            const match = currentItem.display.match(/^([^.]+)\./);
+            if (match) {
+                displayValue = match[1];
+            }
+            else {
+                displayValue = String(selectableIndices.indexOf(selectedIndex) + 1);
+            }
+        }
+        (0, renderer_js_1.renderInputPrompt)(displayPrompt, displayValue);
+        addVisualLines(`  ${displayPrompt} ${displayValue}`);
+        // Render hints if provided (for Page Layout footer)
+        if (hints && hints.length > 0) {
+            (0, renderer_js_1.renderBlankLines)(1);
+            addVisualLines('');
+            (0, renderer_js_2.renderHints)(hints);
+            addVisualLines(`  ${hints.join(' • ')}`);
+        }
         state.renderedLines = lineCount;
     };
     // Initial render
@@ -199,13 +178,15 @@ async function showRadioMenu(config) {
             // Handle Ctrl+C
             if ((0, keyboard_js_1.isCtrlC)(key)) {
                 state.stdin.removeListener('data', onData);
-                (0, terminal_js_1.clearMenu)(state);
+                if (!preserveOnExit) {
+                    (0, terminal_js_1.clearMenu)(state);
+                }
                 (0, terminal_js_1.restoreTerminal)(state);
                 if (onExit) {
                     onExit();
                 }
                 else {
-                    console.log('\n👋 再见!');
+                    console.log(`\n${(0, registry_js_1.t)('messages.goodbye')}`);
                 }
                 process.exit(0);
             }
@@ -215,24 +196,9 @@ async function showRadioMenu(config) {
                 if (!preserveOnSelect) {
                     (0, terminal_js_1.clearMenu)(state);
                 }
-                else {
-                    (0, terminal_js_1.writeLine)('');
-                }
                 (0, terminal_js_1.restoreTerminal)(state);
-                const selectedOption = options[selectedIndex];
-                let value;
-                if (typeof selectedOption === 'string') {
-                    value = selectedOption;
-                }
-                else if ('type' in selectedOption && selectedOption.type === 'separator') {
-                    value = '';
-                }
-                else if ('value' in selectedOption) {
-                    value = selectedOption.value ?? selectedOption.label ?? '';
-                }
-                else {
-                    value = selectedOption.label ?? '';
-                }
+                const selectedItem = optionData[selectedIndex];
+                const value = selectedItem && !selectedItem.isSeparator ? selectedItem.value : '';
                 resolve({
                     index: selectedIndex,
                     value
@@ -266,7 +232,7 @@ async function showRadioMenu(config) {
                     const item = optionData[idx];
                     if (item.isSeparator)
                         return false;
-                    const match = item.value.match(/^([a-zA-Z])\./i);
+                    const match = item.display.match(/^([a-zA-Z])\./i);
                     return match && match[1].toLowerCase() === letter;
                 });
                 if (index !== undefined) {

package/dist/components.js

@@ -33,8 +33,8 @@ const colorCodes = {
 };
 // Theme colors
 exports.theme = {
-    active: `${colorCodes.bright}${exports.colors.cyan}`, // Selected item - bright cyan
-    primary: exports.colors.cyan, // Standard - cyan (numbers, separators)
+    active: `${colorCodes.bright}${exports.colors.reset}`, // Selected item - bright default
+    primary: exports.colors.reset, // Standard text color
     title: exports.colors.reset, // Title - white (menu titles)
     muted: exports.colors.gray, // Auxiliary - gray (descriptions, hints)
     success: exports.colors.green, // Success - green
@@ -46,7 +46,7 @@ exports.symbols = {
     success: { icon: '✓', color: exports.colors.green },
     error: { icon: 'x', color: exports.colors.red },
     warning: { icon: '!', color: exports.colors.yellow },
-    info: { icon: 'ℹ', color: exports.colors.blue },
+    info: { icon: 'ℹ', color: exports.colors.reset },
 };
 /**
  * Format section title with separator

package/dist/config/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Configuration module exports
+ */
+export * from './user-config';
+export * from './language-config';

package/dist/config/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Configuration module exports
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./user-config"), exports);
+__exportStar(require("./language-config"), exports);

package/dist/config/language-config.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Language Configuration System
+ * Supports dynamic language loading from JSON
+ */
+export interface LanguageConfig {
+    code: string;
+    cliCode?: string;
+    label: string;
+    nativeLabel: string;
+    [key: string]: any;
+}
+export interface LanguagesConfig {
+    default: string;
+    languages: LanguageConfig[];
+}
+declare class LanguageManager {
+    private config;
+    private languageMap;
+    constructor(config: LanguagesConfig);
+    /**
+     * Get all supported languages
+     */
+    getLanguages(): LanguageConfig[];
+    /**
+     * Get language config by code
+     */
+    getLanguage(code: string): LanguageConfig | undefined;
+    /**
+     * Get default language code
+     */
+    getDefaultLanguage(): string;
+    /**
+     * Get CLI language code
+     */
+    getCLICode(code: string): string;
+    /**
+     * Check if language is supported
+     */
+    isSupported(code: string): boolean;
+    /**
+     * Get all language codes
+     */
+    getLanguageCodes(): string[];
+}
+/**
+ * Initialize language manager from config
+ */
+export declare function initLanguages(config: LanguagesConfig): LanguageManager;
+/**
+ * Load languages from JSON file
+ */
+export declare function loadLanguagesFromFile(filePath: string): LanguageManager;
+/**
+ * Get global language manager
+ */
+export declare function getLanguageManager(): LanguageManager;
+/**
+ * Get all supported languages
+ */
+export declare function getSupportedLanguages(): LanguageConfig[];
+/**
+ * Get language config
+ */
+export declare function getLanguageConfig(code: string): LanguageConfig | undefined;
+/**
+ * Get default language
+ */
+export declare function getDefaultLanguage(): string;
+/**
+ * Get CLI language code
+ */
+export declare function getCLILanguageCode(code: string): string;
+export {};

package/dist/config/language-config.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * Language Configuration System
+ * Supports dynamic language loading from JSON
+ */
+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.initLanguages = initLanguages;
+exports.loadLanguagesFromFile = loadLanguagesFromFile;
+exports.getLanguageManager = getLanguageManager;
+exports.getSupportedLanguages = getSupportedLanguages;
+exports.getLanguageConfig = getLanguageConfig;
+exports.getDefaultLanguage = getDefaultLanguage;
+exports.getCLILanguageCode = getCLILanguageCode;
+const fs = __importStar(require("fs"));
+class LanguageManager {
+    constructor(config) {
+        this.config = config;
+        this.languageMap = new Map();
+        // Build language map
+        for (const lang of config.languages) {
+            this.languageMap.set(lang.code, lang);
+        }
+    }
+    /**
+     * Get all supported languages
+     */
+    getLanguages() {
+        return this.config.languages;
+    }
+    /**
+     * Get language config by code
+     */
+    getLanguage(code) {
+        return this.languageMap.get(code);
+    }
+    /**
+     * Get default language code
+     */
+    getDefaultLanguage() {
+        return this.config.default;
+    }
+    /**
+     * Get CLI language code
+     */
+    getCLICode(code) {
+        const lang = this.getLanguage(code);
+        return lang?.cliCode || lang?.code || this.getDefaultLanguage();
+    }
+    /**
+     * Check if language is supported
+     */
+    isSupported(code) {
+        return this.languageMap.has(code);
+    }
+    /**
+     * Get all language codes
+     */
+    getLanguageCodes() {
+        return Array.from(this.languageMap.keys());
+    }
+}
+// Global language manager
+let globalLanguageManager = null;
+/**
+ * Initialize language manager from config
+ */
+function initLanguages(config) {
+    globalLanguageManager = new LanguageManager(config);
+    return globalLanguageManager;
+}
+/**
+ * Load languages from JSON file
+ */
+function loadLanguagesFromFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const config = JSON.parse(content);
+        return initLanguages(config);
+    }
+    catch (error) {
+        console.error('Failed to load languages config:', error);
+        throw error;
+    }
+}
+/**
+ * Get global language manager
+ */
+function getLanguageManager() {
+    if (!globalLanguageManager) {
+        // Return default manager if not initialized
+        return new LanguageManager({
+            default: 'en',
+            languages: [
+                { code: 'en', label: 'English', nativeLabel: 'English' },
+                { code: 'zh', label: 'Chinese', nativeLabel: '中文' }
+            ]
+        });
+    }
+    return globalLanguageManager;
+}
+/**
+ * Get all supported languages
+ */
+function getSupportedLanguages() {
+    return getLanguageManager().getLanguages();
+}
+/**
+ * Get language config
+ */
+function getLanguageConfig(code) {
+    return getLanguageManager().getLanguage(code);
+}
+/**
+ * Get default language
+ */
+function getDefaultLanguage() {
+    return getLanguageManager().getDefaultLanguage();
+}
+/**
+ * Get CLI language code
+ */
+function getCLILanguageCode(code) {
+    return getLanguageManager().getCLICode(code);
+}

package/dist/config/user-config.d.ts

@@ -0,0 +1,83 @@
+/**
+ * User Configuration System for CLI Menu Kit
+ * Provides persistent user preferences
+ */
+export interface UserConfig {
+    language?: string;
+    theme?: string;
+    [key: string]: any;
+}
+export interface ConfigOptions {
+    appName: string;
+    configFileName?: string;
+    defaults?: UserConfig;
+}
+declare class ConfigManager {
+    private appName;
+    private configFileName;
+    private defaults;
+    private configDir;
+    private configPath;
+    constructor(options: ConfigOptions);
+    /**
+     * Ensure config directory exists
+     */
+    private ensureConfigDir;
+    /**
+     * Load configuration
+     */
+    load(): UserConfig;
+    /**
+     * Save configuration
+     */
+    save(config: Partial<UserConfig>): void;
+    /**
+     * Get a specific config value
+     */
+    get<K extends keyof UserConfig>(key: K): UserConfig[K];
+    /**
+     * Set a specific config value
+     */
+    set<K extends keyof UserConfig>(key: K, value: UserConfig[K]): void;
+    /**
+     * Reset configuration to defaults
+     */
+    reset(): void;
+    /**
+     * Get config file path
+     */
+    getConfigPath(): string;
+    /**
+     * Get config directory path
+     */
+    getConfigDir(): string;
+}
+/**
+ * Initialize config manager
+ */
+export declare function initConfig(options: ConfigOptions): ConfigManager;
+/**
+ * Get global config manager
+ */
+export declare function getConfigManager(): ConfigManager;
+/**
+ * Load configuration
+ */
+export declare function loadConfig(): UserConfig;
+/**
+ * Save configuration
+ */
+export declare function saveConfig(config: Partial<UserConfig>): void;
+/**
+ * Get config value
+ */
+export declare function getConfig<K extends keyof UserConfig>(key: K): UserConfig[K];
+/**
+ * Set config value
+ */
+export declare function setConfig<K extends keyof UserConfig>(key: K, value: UserConfig[K]): void;
+/**
+ * Reset configuration
+ */
+export declare function resetConfig(): void;
+export {};