@ry-krystal/kicad-converter/dist/core/index.js

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

/**
 * KiCad转换器核心模块导出
 * 提供完整的KiCad符号文件转换功能
 */
// 导出类型定义
export * from './types.js';
// 导出核心类
export { KiCadParser } from './parser.js';
export { JsonConverter } from './converter.js';
export { KiCadGenerator } from './generator.js';
export { KiCadValidator } from './validator.js';
// 导出主要接口类
import { KiCadParser } from './parser.js';
import { JsonConverter } from './converter.js';
import { KiCadGenerator } from './generator.js';
import { KiCadValidator } from './validator.js';
/**
 * 核心转换器类 - 统一的转换接口
 */
export class KiCadConverter {
    parser;
    jsonConverter;
    generator;
    validator;
    constructor(generatorOptions, validationConfig) {
        this.parser = new KiCadParser();
        this.jsonConverter = new JsonConverter();
        this.generator = new KiCadGenerator(generatorOptions);
        this.validator = new KiCadValidator(validationConfig);
    }
    /**
     * 将KiCad文件内容转换为JSON格式
     * @param kicadContent KiCad文件内容
     * @param options 转换选项
     * @returns 转换结果
     */
    async kicadToJson(kicadContent, options = {}) {
        try {
            // 解析KiCad文件
            const symbolLib = this.parser.parse(kicadContent);
            // 验证数据（如果启用）
            if (options.validateOutput) {
                const validation = this.validator.validateSymbolLib(symbolLib);
                if (!validation.isValid) {
                    return {
                        success: false,
                        errors: validation.errors,
                        warnings: validation.warnings
                    };
                }
            }
            // 转换为JSON
            return this.jsonConverter.toJson(symbolLib, options);
        }
        catch (error) {
            return {
                success: false,
                data: undefined,
                errors: [`转换失败: ${error instanceof Error ? error.message : String(error)}`],
                warnings: []
            };
        }
    }
    /**
     * 将JSON格式转换为KiCad文件内容
     * @param jsonContent JSON内容
     * @param options 转换选项
     * @returns 转换结果
     */
    async jsonToKicad(jsonContent, options = {}) {
        try {
            // 解析JSON
            const jsonResult = this.jsonConverter.fromJson(jsonContent, options);
            if (!jsonResult.success || !jsonResult.data) {
                return {
                    success: false,
                    data: undefined,
                    errors: jsonResult.errors,
                    warnings: jsonResult.warnings || []
                };
            }
            // 生成KiCad文件
            return this.generator.generate(jsonResult.data, options);
        }
        catch (error) {
            return {
                success: false,
                data: undefined,
                errors: [`转换失败: ${error instanceof Error ? error.message : String(error)}`],
                warnings: []
            };
        }
    }
    /**
     * 验证KiCad数据结构
     * @param symbolLib 符号库数据
     * @returns 验证结果
     */
    validate(symbolLib) {
        return this.validator.validateSymbolLib(symbolLib);
    }
    /**
     * 获取符号库统计信息
     * @param symbolLib 符号库数据
     * @returns 统计信息
     */
    getStatistics(symbolLib) {
        return this.jsonConverter.getStatistics(symbolLib);
    }
    /**
     * 验证KiCad文件内容是否有效
     * @param kicadContent KiCad文件内容
     * @returns 验证结果
     */
    async validateKiCadContent(kicadContent) {
        try {
            const symbolLib = this.parser.parse(kicadContent);
            return this.validator.validateSymbolLib(symbolLib);
        }
        catch (error) {
            return {
                isValid: false,
                errors: [`解析失败: ${error instanceof Error ? error.message : String(error)}`],
                warnings: [],
                suggestions: []
            };
        }
    }
    /**
     * 验证JSON内容是否有效
     * @param jsonContent JSON内容
     * @returns 验证结果
     */
    async validateJsonContent(jsonContent) {
        try {
            const jsonResult = this.jsonConverter.fromJson(jsonContent);
            if (!jsonResult.success || !jsonResult.data) {
                return {
                    isValid: false,
                    errors: jsonResult.errors,
                    warnings: jsonResult.warnings || [],
                    suggestions: []
                };
            }
            return this.validator.validateSymbolLib(jsonResult.data);
        }
        catch (error) {
            return {
                isValid: false,
                errors: [`JSON解析失败: ${error instanceof Error ? error.message : String(error)}`],
                warnings: [],
                suggestions: []
            };
        }
    }
}
/**
 * 便捷函数：KiCad转JSON
 */
export async function convertKiCadToJson(kicadContent, options = {}) {
    const converter = new KiCadConverter();
    return converter.kicadToJson(kicadContent, options);
}
/**
 * 便捷函数：JSON转KiCad
 */
export async function convertJsonToKicad(jsonContent, options = {}) {
    const converter = new KiCadConverter();
    return converter.jsonToKicad(jsonContent, options);
}
/**
 * 便捷函数：验证KiCad内容
 */
export async function validateKiCad(kicadContent) {
    const converter = new KiCadConverter();
    return converter.validateKiCadContent(kicadContent);
}
/**
 * 便捷函数：验证JSON内容
 */
export async function validateJson(jsonContent) {
    const converter = new KiCadConverter();
    return converter.validateJsonContent(jsonContent);
}