@ry-krystal/kicad-converter/dist/cli/commands/convert.js

专业的KiCad符号文件与JSON互转工具

/**
 * 转换命令实现
 * 处理单文件转换逻辑
 */
import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
import { dirname, extname, basename } from 'path';
import { performance } from 'perf_hooks';
// 导入转换器
import { convertKiCadToJson, convertJsonToKicad } from '../../core/index.js';
import { enhancedKicadToJson, enhancedJsonToKicad } from '../../enhanced/index.js';
// 导入工具
import { createLogger, colors, formatDuration, formatFileSize } from '../utils/index.js';
/**
 * 执行转换命令
 */
export async function convertCommand(options) {
    const logger = createLogger(options.verbose, options.quiet);
    const startTime = performance.now();
    try {
        // 验证输入文件
        if (!existsSync(options.input)) {
            logger.error(`输入文件不存在: ${options.input}`);
            return false;
        }
        // 自动检测转换模式
        const mode = detectConversionMode(options.input, options.mode);
        logger.debug(`检测到转换模式: ${mode}`);
        // 选择转换引擎
        const engine = selectEngine(options.engine, mode);
        logger.debug(`选择转换引擎: ${engine}`);
        // 生成输出路径
        const outputPath = generateOutputPath(options.input, mode, options.output);
        logger.debug(`输出路径: ${outputPath}`);
        // 显示转换信息
        if (!options.quiet) {
            console.log('\\n🔄 开始转换...');
            console.log(`   输入: ${options.input}`);
            console.log(`   输出: ${outputPath}`);
            console.log(`   模式: ${mode === 'to-json' ? 'KiCad → JSON' : 'JSON → KiCad'}`);
            console.log(`   引擎: ${engine === 'enhanced' ? '增强版' : '核心版'}`);
            console.log('');
        }
        // 读取输入文件
        const inputContent = readFileSync(options.input, 'utf8');
        const inputSize = inputContent.length;
        logger.verbose(`读取输入文件: ${formatFileSize(inputSize)}`);
        // 执行转换
        const conversionResult = await performConversion(inputContent, mode, engine, {
            validateOutput: options.validate,
            optimizeOutput: options.optimize,
            verbose: options.verbose,
            quiet: options.quiet
        });
        // 检查转换结果
        if (!conversionResult.success) {
            logger.error('转换失败');
            conversionResult.errors.forEach(error => {
                console.error(`  ${colors.error('•')} ${error}`);
            });
            return false;
        }
        // 确保输出目录存在
        const outputDir = dirname(outputPath);
        if (!existsSync(outputDir)) {
            mkdirSync(outputDir, { recursive: true });
            logger.verbose(`创建输出目录: ${outputDir}`);
        }
        // 写入输出文件
        writeFileSync(outputPath, conversionResult.data);
        const outputSize = conversionResult.data.length;
        const endTime = performance.now();
        const totalDuration = endTime - startTime;
        // 显示成功信息
        if (!options.quiet) {
            console.log(`${colors.success('✅ 转换完成!')}`);
            console.log(`   总耗时: ${formatDuration(totalDuration)}`);
            console.log(`   输出大小: ${formatFileSize(outputSize)}`);
            if (mode === 'to-json') {
                const compressionRatio = ((inputSize - outputSize) / inputSize * 100).toFixed(1);
                console.log(`   压缩率: ${compressionRatio}%`);
            }
        }
        // 显示统计信息
        if (options.stats && conversionResult.statistics) {
            displayStatistics(conversionResult.statistics);
        }
        // 显示警告
        if (conversionResult.warnings.length > 0) {
            console.log(`\n${colors.warning('⚠️  警告:')}`);
            conversionResult.warnings.forEach(warning => {
                console.log(`  ${colors.warning('•')} ${warning}`);
            });
        }
        return true;
    }
    catch (error) {
        logger.error(`转换过程中发生错误: ${error instanceof Error ? error.message : String(error)}`);
        return false;
    }
}
/**
 * 检测转换模式
 */
function detectConversionMode(inputFile, mode) {
    if (mode === 'to-json')
        return 'to-json';
    if (mode === 'to-kicad')
        return 'to-kicad';
    const ext = extname(inputFile).toLowerCase();
    if (ext === '.kicad_sym')
        return 'to-json';
    if (ext === '.json')
        return 'to-kicad';
    // 默认转换为JSON
    return 'to-json';
}
/**
 * 选择转换引擎
 */
function selectEngine(engine, mode) {
    if (engine === 'core')
        return 'core';
    if (engine === 'enhanced')
        return 'enhanced';
    // 自动选择：对于复杂的转换使用增强版
    // 简单转换使用核心版以保证稳定性
    return 'core';
}
/**
 * 生成输出文件路径
 */
function generateOutputPath(inputFile, mode, outputFile) {
    if (outputFile)
        return outputFile;
    const dir = dirname(inputFile);
    const name = basename(inputFile, extname(inputFile));
    if (mode === 'to-json') {
        return `${dir}/${name}.json`;
    }
    else {
        return `${dir}/${name}.kicad_sym`;
    }
}
/**
 * 执行转换
 */
async function performConversion(content, mode, engine, options) {
    if (mode === 'to-json') {
        if (engine === 'enhanced') {
            return enhancedKicadToJson(content, options);
        }
        else {
            return convertKiCadToJson(content, options);
        }
    }
    else {
        if (engine === 'enhanced') {
            const jsonData = JSON.parse(content);
            return enhancedJsonToKicad(jsonData, options);
        }
        else {
            return convertJsonToKicad(content, options);
        }
    }
}
/**
 * 显示统计信息
 */
function displayStatistics(stats) {
    console.log(`\n${colors.info('📊 详细统计:')}`);
    console.log(`   处理时间: ${formatDuration(stats.processingTime)}`);
    console.log(`   输入大小: ${formatFileSize(stats.inputSize)}`);
    console.log(`   输出大小: ${formatFileSize(stats.outputSize)}`);
    if (stats.symbolCount !== undefined) {
        console.log(`   符号数量: ${stats.symbolCount}`);
    }
    if (stats.pinCount !== undefined) {
        console.log(`   引脚数量: ${stats.pinCount}`);
    }
    if (stats.propertyCount !== undefined) {
        console.log(`   属性数量: ${stats.propertyCount}`);
    }
}
/**
 * 验证转换结果
 */
export function validateConversionResult(result, mode) {
    if (!result.success) {
        return false;
    }
    if (!result.data) {
        return false;
    }
    // 简单的结果验证
    if (mode === 'to-json') {
        try {
            JSON.parse(result.data);
            return true;
        }
        catch {
            return false;
        }
    }
    else {
        // 验证KiCad格式
        return typeof result.data === 'string' && result.data.includes('kicad_symbol_lib');
    }
}