trackswap 0.0.1 → 0.0.2

package/dist/TCX/decoder.js

@@ -0,0 +1,350 @@
+import { PositionConverter, TrackpointConverter, TrackConverter, ActivityLapConverter, ActivityConverter, ActivityListConverter, MultiSportSessionConverter, AbstractSourceConverter, } from "./converters.js";
+import { AstGenerateProcessor, CompleteProcessor, ConvertProcessor, TokenizeProcessor, PipelineStage, } from "./processor.js";
+/**
+ * https://www8.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd
+ */
+export class TCXDecoder {
+    constructor() {
+        this.converterPlugins = new Map();
+        this.registeredPlugins = new Set(); // 跟踪已注册的插件名
+        this.middlewarePlugins = [];
+        this.processors = []; // 固定的核心处理器
+        this.initialized = false;
+        this.defaultConvertersRegistered = false;
+        this.initializePipeline();
+    }
+    /**
+     * 初始化流水线 - 注册固定的核心处理器
+     */
+    initializePipeline() {
+        // 固定的核心处理器，不允许用户修改
+        this.processors = [
+            new TokenizeProcessor(),
+            new AstGenerateProcessor(),
+            new ConvertProcessor((tag) => this.getConverter(tag)),
+            new CompleteProcessor(),
+        ];
+        console.log("🔧 TCX核心流水线处理器已初始化 (固定不可修改)");
+    }
+    /**
+     * 自动注册默认转换器 - 处理标准TCX标签
+     */
+    async registerDefaultConverters() {
+        if (this.defaultConvertersRegistered)
+            return;
+        const defaultConverters = [
+            new PositionConverter(),
+            new TrackpointConverter(),
+            new TrackConverter(),
+            new ActivityLapConverter(),
+            new ActivityConverter(),
+            new ActivityListConverter(),
+            new MultiSportSessionConverter(),
+            new AbstractSourceConverter(),
+        ];
+        for (const converter of defaultConverters) {
+            // 内部注册，不显示日志避免干扰
+            converter.supportedTags?.forEach((tag) => {
+                this.addConverterForTag(tag, converter);
+            });
+            this.registeredPlugins.add(converter.name);
+        }
+        this.defaultConvertersRegistered = true;
+        console.log("✅ 默认TCX转换器已自动注册 (Activities, Position, Track等)");
+    }
+    /**
+     * 为指定标签添加转换器，按优先级排序
+     */
+    addConverterForTag(tag, converter) {
+        if (!this.converterPlugins.has(tag)) {
+            this.converterPlugins.set(tag, []);
+        }
+        const converters = this.converterPlugins.get(tag);
+        converters.push(converter);
+        // 按优先级排序（数字越小优先级越高）
+        converters.sort((a, b) => (a.priority || 100) - (b.priority || 100));
+    }
+    /**
+     * 注册转换器插件
+     */
+    async registerConverter(plugin) {
+        // 检查插件是否已注册
+        if (this.registeredPlugins.has(plugin.name)) {
+            throw new Error(`转换器插件 ${plugin.name} 已存在`);
+        }
+        // 注册支持的标签（允许多个转换器处理同一标签）
+        plugin.supportedTags?.forEach((tag) => {
+            this.addConverterForTag(tag, plugin);
+        });
+        this.registeredPlugins.add(plugin.name);
+        // 显示优先级信息
+        const priorityInfo = plugin.priority !== undefined ? ` (优先级: ${plugin.priority})` : "";
+        console.log(`📦 已注册自定义TCX转换器: ${plugin.name}${priorityInfo}, 支持标签: ${plugin.supportedTags?.join(", ")}`);
+        // 显示标签的转换器优先级顺序
+        plugin.supportedTags?.forEach((tag) => {
+            const converters = this.converterPlugins.get(tag) || [];
+            const converterNames = converters.map((c) => `${c.name}(${c.priority || 100})`);
+            console.log(`   📋 标签 "${tag}" 转换器优先级: ${converterNames.join(" > ")}`);
+        });
+    }
+    /**
+     * 注册中间件插件 - 真正的扩展点
+     */
+    async registerMiddleware(plugin) {
+        const existingIndex = this.middlewarePlugins.findIndex((p) => p.name === plugin.name);
+        if (existingIndex !== -1) {
+            this.middlewarePlugins[existingIndex] = plugin;
+            console.log(`🔄 已更新TCX中间件: ${plugin.name}`);
+        }
+        else {
+            this.middlewarePlugins.push(plugin);
+            console.log(`🔌 已注册TCX中间件: ${plugin.name}`);
+        }
+        // 显示中间件支持的钩子
+        const hooks = [];
+        if (plugin.onTokenize)
+            hooks.push("onTokenize");
+        if (plugin.onAstGenerate)
+            hooks.push("onAstGenerate");
+        if (plugin.onConvert)
+            hooks.push("onConvert");
+        if (plugin.onComplete)
+            hooks.push("onComplete");
+        if (plugin.onError)
+            hooks.push("onError");
+        if (hooks.length > 0) {
+            console.log(`   🎣 支持的钩子: ${hooks.join(", ")}`);
+        }
+    }
+    /**
+     * 获取转换器（返回优先级最高的）
+     */
+    getConverter(tag) {
+        const converters = this.converterPlugins.get(tag);
+        return converters && converters.length > 0 ? converters[0] : undefined;
+    }
+    /**
+     * 获取指定标签的所有转换器（按优先级排序）
+     */
+    getAllConverters(tag) {
+        return this.converterPlugins.get(tag) || [];
+    }
+    /**
+     * 移除转换器
+     */
+    unregisterConverter(pluginName) {
+        // 找到插件实例
+        let pluginToRemove;
+        for (const [tag, converters] of this.converterPlugins) {
+            const index = converters.findIndex((plugin) => plugin.name === pluginName);
+            if (index !== -1) {
+                pluginToRemove = converters[index];
+                converters.splice(index, 1);
+                // 如果该标签没有转换器了，删除整个条目
+                if (converters.length === 0) {
+                    this.converterPlugins.delete(tag);
+                }
+            }
+        }
+        if (!pluginToRemove) {
+            console.warn(`TCX转换器插件 ${pluginName} 不存在`);
+            return;
+        }
+        this.registeredPlugins.delete(pluginName);
+        console.log(`🗑️ 已移除TCX转换器: ${pluginName}`);
+    }
+    /**
+     * 移除中间件
+     */
+    unregisterMiddleware(name) {
+        const index = this.middlewarePlugins.findIndex((p) => p.name === name);
+        if (index !== -1) {
+            this.middlewarePlugins.splice(index, 1);
+            console.log(`🗑️ 已移除TCX中间件: ${name}`);
+        }
+        else {
+            console.warn(`TCX中间件 ${name} 不存在`);
+        }
+    }
+    /**
+     * 初始化解码器
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        // 首先注册默认转换器
+        await this.registerDefaultConverters();
+        const context = this.createContext();
+        // 初始化所有插件
+        const allPlugins = [
+            ...Array.from(this.converterPlugins.values()).flat(),
+            ...this.middlewarePlugins,
+        ];
+        for (const plugin of allPlugins) {
+            try {
+                await plugin.initialize?.(context);
+            }
+            catch (error) {
+                console.error(`TCX插件 ${plugin.name} 初始化失败:`, error);
+            }
+        }
+        this.initialized = true;
+    }
+    /**
+     * 销毁解码器
+     */
+    async destroy() {
+        if (!this.initialized)
+            return;
+        const context = this.createContext();
+        // 销毁所有插件
+        const allPlugins = [
+            ...Array.from(this.converterPlugins.values()).flat(),
+            ...this.middlewarePlugins,
+        ];
+        for (const plugin of allPlugins) {
+            try {
+                await plugin.destroy?.(context);
+            }
+            catch (error) {
+                console.error(`TCX插件 ${plugin.name} 销毁失败:`, error);
+            }
+        }
+        this.initialized = false;
+    }
+    /**
+     * 创建解码上下文
+     */
+    createContext() {
+        return {
+            metadata: new Map(),
+            errors: [],
+            warnings: [],
+            stats: {
+                startTime: Date.now(),
+                processedTokens: 0,
+                convertedElements: 0,
+            },
+            performance: {
+                startTime: Date.now(),
+            },
+        };
+    }
+    /**
+     * 执行中间件钩子
+     */
+    async executeMiddlewareHook(hookName, data, context) {
+        let result = data;
+        for (const middleware of this.middlewarePlugins) {
+            const hook = middleware[hookName];
+            if (hook) {
+                try {
+                    result = (await hook.call(middleware, result, context)) || result;
+                }
+                catch (error) {
+                    context.errors.push(error);
+                    await middleware.onError?.(error, context);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * 主解析方法 - 固定的流水线 + 灵活的中间件
+     */
+    async parseByBuffer(buffer) {
+        await this.initialize();
+        let context = this.createContext();
+        context.rawData = buffer;
+        context.xmlContent = buffer.toString("utf-8");
+        // 在上下文中传递解码器实例引用
+        context.metadata.set("decoder", this);
+        try {
+            // 固定的流水线阶段顺序执行
+            for (const processor of this.processors) {
+                try {
+                    // 1. 执行核心处理器
+                    context = await processor.process(context);
+                    // 2. 根据阶段执行对应的中间件钩子
+                    switch (processor.stage) {
+                        case PipelineStage.TOKENIZE:
+                            if (context.tokens) {
+                                context.tokens = await this.executeMiddlewareHook("onTokenize", context.tokens, context);
+                            }
+                            break;
+                        case PipelineStage.AST_GENERATE:
+                            if (context.ast) {
+                                context.ast = await this.executeMiddlewareHook("onAstGenerate", context.ast, context);
+                            }
+                            break;
+                        case PipelineStage.CONVERT:
+                            if (context.result) {
+                                context.result = await this.executeMiddlewareHook("onConvert", context.result, context);
+                            }
+                            break;
+                        case PipelineStage.COMPLETE:
+                            if (context.result) {
+                                context.result = await this.executeMiddlewareHook("onComplete", context.result, context);
+                            }
+                            break;
+                    }
+                }
+                catch (error) {
+                    context.errors.push(error);
+                    // 执行错误处理中间件
+                    for (const middleware of this.middlewarePlugins) {
+                        await middleware.onError?.(error, context);
+                    }
+                    console.error(`TCX流水线阶段 ${processor.stage} 处理失败:`, error);
+                }
+            }
+            return context.result;
+        }
+        catch (error) {
+            console.error("TCX解析失败:", error);
+            throw error;
+        }
+    }
+    /**
+     * 转换Extensions（向后兼容）
+     */
+    convertExtensions(extensionsAST) {
+        const extensions = {};
+        const { attributes, tag, value } = extensionsAST;
+        // 处理属性
+        if (attributes) {
+            Object.entries(attributes).forEach(([key, value]) => {
+                extensions[key] = value;
+            });
+        }
+        // 如果有子节点，直接处理子节点，不再包装外层标签
+        if (extensionsAST?.children?.length) {
+            extensionsAST.children?.forEach((child) => {
+                extensions[child.tag] =
+                    this.convertExtensions(child);
+            });
+        }
+        else if (value !== undefined) {
+            // 如果没有子节点但有值，直接返回值
+            return value;
+        }
+        return extensions;
+    }
+    // ==================== 向后兼容方法 ====================
+    /**
+     * @deprecated 使用 parseByBuffer 替代
+     */
+    async parserByBuffer(buffer) {
+        return this.parseByBuffer(buffer);
+    }
+    /**
+     * @deprecated 使用新的插件系统替代
+     */
+    async parseByString(xmlContent) {
+        const buffer = Buffer.from(xmlContent, "utf-8");
+        return this.parseByBuffer(buffer);
+    }
+}
+export default {
+    TCXDecoder,
+};

package/dist/TCX/encoder.d.ts

@@ -0,0 +1,150 @@
+import { TCXFileType } from "./types.js";
+/**
+ * TCX 编码器 - 将 TCXFileType 数据编码为 TCX XML 格式
+ */
+export declare class TCXEncoder {
+    private compact;
+    /**
+     * 构造函数
+     * @param options 编码器选项
+     */
+    constructor(options?: {
+        compact?: boolean;
+    });
+    /**
+     * 编码 TCX 数据为 Buffer
+     */
+    encode(tcxData: TCXFileType): Promise<Buffer>;
+    /**
+     * 编码 TCX 数据为 XML 字符串
+     */
+    encodeToString(tcxData: TCXFileType): string;
+    /**
+     * 构建完整的 TCX XML
+     */
+    private buildTCXXML;
+    /**
+     * 压缩XML字符串，去掉多余的换行和空格
+     */
+    private compressXML;
+    /**
+     * 构建 XML 头部
+     */
+    private buildXMLHeader;
+    /**
+     * 构建 TCX 内容
+     */
+    private buildTCXContent;
+    /**
+     * 构建 Folders 元素
+     */
+    private buildFolders;
+    /**
+     * 构建 History 元素
+     */
+    private buildHistory;
+    /**
+     * 构建 HistoryFolder 元素
+     */
+    private buildHistoryFolder;
+    /**
+     * 构建 Activities 元素
+     */
+    private buildActivities;
+    /**
+     * 构建单个 Activity 元素
+     */
+    private buildActivity;
+    /**
+     * 构建 ActivityLap 元素
+     */
+    private buildActivityLap;
+    /**
+     * 构建 Track 元素
+     */
+    private buildTrack;
+    /**
+     * 构建 Trackpoint 元素
+     */
+    private buildTrackpoint;
+    /**
+     * 构建 Position 元素
+     */
+    private buildPosition;
+    /**
+     * 构建 Cadence 元素
+     */
+    private buildCadence;
+    /**
+     * 构建 MultiSportSession 元素
+     */
+    private buildMultiSportSession;
+    /**
+     * 构建 FirstSport 元素
+     */
+    private buildFirstSport;
+    /**
+     * 构建 NextSport 元素
+     */
+    private buildNextSport;
+    /**
+     * 构建 Workouts 元素
+     */
+    private buildWorkouts;
+    /**
+     * 构建 Courses 元素
+     */
+    private buildCourses;
+    /**
+     * 构建 Author 元素
+     */
+    private buildAuthor;
+    /**
+     * 构建扩展元素
+     */
+    private buildExtensions;
+    /**
+     * 递归构建扩展内容
+     */
+    private buildExtensionContent;
+    /**
+     * 格式化时间
+     */
+    private formatTime;
+    /**
+     * 添加可选元素
+     */
+    private addOptionalElement;
+    /**
+     * 添加可选数值元素
+     */
+    private addOptionalNumericElement;
+    /**
+     * 验证坐标有效性
+     */
+    private isValidCoordinate;
+    /**
+     * 格式化坐标
+     */
+    private formatCoordinate;
+    /**
+     * 数字四舍五入
+     */
+    private roundTo;
+    /**
+     * XML 转义
+     */
+    private escapeXML;
+    /**
+     * XML 属性值转义（专门用于属性值的安全转义）
+     */
+    private escapeXMLAttribute;
+    /**
+     * 深度拷贝
+     */
+    private deepClone;
+    /**
+     * @deprecated 使用 encode() 替代
+     */
+    encoder(node: TCXFileType): Promise<Buffer>;
+}