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

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

/**
 * 批量转换命令实现
 * 处理目录批量转换逻辑
 */
import { statSync, existsSync, mkdirSync } from 'fs';
import { join, extname, basename, dirname } from 'path';
// 导入工具
import { createLogger, findFiles } from '../utils/index.js';
import { convertCommand } from './convert.js';
/**
 * 执行批量转换命令
 */
export async function batchCommand(options) {
    const logger = createLogger(options.verbose, options.quiet);
    try {
        // 验证输入目录
        if (!existsSync(options.input)) {
            logger.error(`输入目录不存在: ${options.input}`);
            return false;
        }
        const inputStat = statSync(options.input);
        if (!inputStat.isDirectory()) {
            logger.error(`输入路径不是目录: ${options.input}`);
            return false;
        }
        // 查找需要转换的文件
        const supportedExtensions = ['.kicad_sym', '.json'];
        const filesToProcess = findFiles(options.input, supportedExtensions, options.recursive);
        if (filesToProcess.length === 0) {
            logger.warn(`在目录 ${options.input} 中未找到支持的文件`);
            logger.info(`支持的文件扩展名: ${supportedExtensions.join(', ')}`);
            return true;
        }
        logger.info(`发现 ${filesToProcess.length} 个文件需要处理`);
        // 处理每个文件
        let successCount = 0;
        let errorCount = 0;
        for (let i = 0; i < filesToProcess.length; i++) {
            const file = filesToProcess[i];
            const outputPath = generateOutputPath(file, options);
            // 确保输出目录存在
            const outputDir = dirname(outputPath);
            if (!existsSync(outputDir)) {
                mkdirSync(outputDir, { recursive: true });
            }
            // 执行转换
            const success = await convertCommand({
                input: file,
                output: outputPath,
                mode: options.mode,
                engine: options.engine,
                validate: options.validate,
                optimize: options.optimize,
                stats: false,
                verbose: false,
                quiet: true
            });
            if (success) {
                successCount++;
                if (options.verbose) {
                    logger.info(`✓ ${basename(file)}`);
                }
            }
            else {
                errorCount++;
                logger.error(`✗ ${basename(file)}`);
            }
        }
        // 显示结果摘要
        logger.info(`批量处理完成`);
        logger.info(`总文件数: ${filesToProcess.length}`);
        logger.info(`成功: ${successCount}`);
        if (errorCount > 0) {
            logger.info(`失败: ${errorCount}`);
        }
        return errorCount === 0;
    }
    catch (error) {
        logger.error(`批量转换过程中发生错误: ${error instanceof Error ? error.message : String(error)}`);
        return false;
    }
}
/**
 * 生成输出路径
 */
function generateOutputPath(inputFile, options) {
    const inputExt = extname(inputFile);
    const inputName = basename(inputFile, inputExt);
    const inputDir = dirname(inputFile);
    // 确定输出扩展名
    let outputExt;
    if (options.mode === 'to-json' || (options.mode === 'auto' && inputExt === '.kicad_sym')) {
        outputExt = '.json';
    }
    else {
        outputExt = '.kicad_sym';
    }
    // 确定输出目录
    let outputDir;
    if (options.output) {
        const relativePath = inputDir.replace(options.input, '');
        outputDir = join(options.output, relativePath);
    }
    else {
        outputDir = inputDir;
    }
    return join(outputDir, `${inputName}${outputExt}`);
}