trackswap 0.0.1 → 0.0.2

package/dist/TCX/encoder.js

@@ -0,0 +1,513 @@
+import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc.js";
+// 配置 dayjs UTC 插件
+dayjs.extend(utc);
+/**
+ * TCX 编码器 - 将 TCXFileType 数据编码为 TCX XML 格式
+ */
+export class TCXEncoder {
+    /**
+     * 构造函数
+     * @param options 编码器选项
+     */
+    constructor(options = {}) {
+        this.compact = options.compact ?? true;
+    }
+    // ==================== 公共接口 ====================
+    /**
+     * 编码 TCX 数据为 Buffer
+     */
+    async encode(tcxData) {
+        const xmlContent = this.buildTCXXML(tcxData);
+        return Buffer.from(xmlContent, "utf-8");
+    }
+    /**
+     * 编码 TCX 数据为 XML 字符串
+     */
+    encodeToString(tcxData) {
+        return this.buildTCXXML(tcxData);
+    }
+    // ==================== 核心构建方法 ====================
+    /**
+     * 构建完整的 TCX XML
+     */
+    buildTCXXML(tcxData) {
+        const header = this.buildXMLHeader(tcxData);
+        const content = this.buildTCXContent(tcxData);
+        const footer = "</TrainingCenterDatabase>";
+        const xml = `${header}${content}\n${footer}`;
+        // 如果启用压缩模式，则压缩XML
+        return this.compact ? this.compressXML(xml) : xml;
+    }
+    /**
+     * 压缩XML字符串，去掉多余的换行和空格
+     */
+    compressXML(xml) {
+        return (xml
+            // 去掉标签之间的换行和多余空格
+            .replace(/>\s+</g, "><")
+            // 去掉行首行尾的空白字符
+            .replace(/^\s+|\s+$/gm, "")
+            // 将多个连续空格替换为单个空格
+            .replace(/\s+/g, " ")
+            // 去掉整体的首尾空白
+            .trim());
+    }
+    /**
+     * 构建 XML 头部
+     */
+    buildXMLHeader(tcxData) {
+        const version = tcxData.version || "1.0";
+        const creator = tcxData.creator || "trackswap";
+        const xmlns = tcxData.xmlns ||
+            "http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2";
+        const xmlnsXsi = tcxData["xmlns:xsi"] || "http://www.w3.org/2001/XMLSchema-instance";
+        const xsiSchemaLocation = tcxData["xsi:schemaLocation"] ||
+            "http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2 http://www8.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd";
+        return [
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            `<TrainingCenterDatabase version="${this.escapeXMLAttribute(version)}"`,
+            `                       creator="${this.escapeXMLAttribute(creator)}"`,
+            `                       xmlns="${this.escapeXMLAttribute(xmlns)}"`,
+            `                       xmlns:xsi="${this.escapeXMLAttribute(xmlnsXsi)}"`,
+            `                       xsi:schemaLocation="${this.escapeXMLAttribute(xsiSchemaLocation)}">`,
+        ].join("\n");
+    }
+    /**
+     * 构建 TCX 内容
+     */
+    buildTCXContent(tcxData) {
+        const parts = [];
+        // 按标准 TCX 顺序构建内容
+        if (tcxData.Folders) {
+            parts.push(this.buildFolders(tcxData.Folders));
+        }
+        if (tcxData.Activities) {
+            parts.push(this.buildActivities(tcxData.Activities));
+        }
+        if (tcxData.Workouts) {
+            parts.push(this.buildWorkouts(tcxData.Workouts));
+        }
+        if (tcxData.Courses) {
+            parts.push(this.buildCourses(tcxData.Courses));
+        }
+        if (tcxData.Author) {
+            parts.push(this.buildAuthor(tcxData.Author));
+        }
+        if (tcxData.Extensions) {
+            parts.push(this.buildExtensions(tcxData.Extensions));
+        }
+        return parts.join("\n");
+    }
+    // ==================== 结构元素构建 ====================
+    /**
+     * 构建 Folders 元素
+     */
+    buildFolders(folders) {
+        const parts = ["<Folders>"];
+        if (folders.History) {
+            parts.push(this.buildHistory(folders.History));
+        }
+        if (folders.Workouts) {
+            parts.push(this.buildWorkouts(folders.Workouts));
+        }
+        if (folders.Courses) {
+            // TODO: 处理 Courses
+            console.warn("Courses in Folders 暂未实现");
+        }
+        parts.push("</Folders>");
+        return parts.join("\n  ");
+    }
+    /**
+     * 构建 History 元素
+     */
+    buildHistory(history) {
+        const parts = ["<History>"];
+        if (history.Running) {
+            parts.push(`<Running>${this.buildHistoryFolder(history.Running)}</Running>`);
+        }
+        if (history.Biking) {
+            parts.push(`<Biking>${this.buildHistoryFolder(history.Biking)}</Biking>`);
+        }
+        if (history.Other) {
+            parts.push(`<Other>${this.buildHistoryFolder(history.Other)}</Other>`);
+        }
+        if (history.MultiSport) {
+            parts.push(`<MultiSport>${this.buildHistoryFolder(history.MultiSport)}</MultiSport>`);
+        }
+        if (history.Extensions) {
+            parts.push(this.buildExtensions(history.Extensions));
+        }
+        parts.push("</History>");
+        return parts.join("\n    ");
+    }
+    /**
+     * 构建 HistoryFolder 元素
+     */
+    buildHistoryFolder(folder) {
+        // TODO: 实现详细的 HistoryFolder 构建
+        return "";
+    }
+    /**
+     * 构建 Activities 元素
+     */
+    buildActivities(activities) {
+        const parts = ["<Activities>"];
+        if (activities.Activity) {
+            activities.Activity.forEach((activity) => {
+                parts.push(this.buildActivity(activity));
+            });
+        }
+        if (activities.MultiSportSession) {
+            activities.MultiSportSession.forEach((session) => {
+                parts.push(this.buildMultiSportSession(session));
+            });
+        }
+        parts.push("</Activities>");
+        return parts.join("\n  ");
+    }
+    /**
+     * 构建单个 Activity 元素
+     */
+    buildActivity(activity) {
+        const sport = activity.Sport || "Other";
+        const parts = [`<Activity Sport="${sport}">`];
+        // ID 是必需的
+        parts.push(`<Id>${this.formatTime(activity.Id)}</Id>`);
+        // Lap 是必需的
+        if (activity.Lap && activity.Lap.length > 0) {
+            activity.Lap.forEach((lap) => {
+                parts.push(this.buildActivityLap(lap));
+            });
+        }
+        // 可选元素
+        this.addOptionalElement(parts, "Notes", activity.Notes);
+        if (activity.Training) {
+            // TODO: 实现 Training 元素
+            console.warn("Activity Training 暂未实现");
+        }
+        if (activity.Creator) {
+            // TODO: 实现 Creator 元素
+            console.warn("Activity Creator 暂未实现");
+        }
+        if (activity.Extensions) {
+            parts.push(this.buildExtensions(activity.Extensions));
+        }
+        parts.push("</Activity>");
+        return parts.join("\n    ");
+    }
+    /**
+     * 构建 ActivityLap 元素
+     */
+    buildActivityLap(lap) {
+        const parts = ["<Lap>"];
+        // 时间相关
+        this.addOptionalNumericElement(parts, "TotalTimeSeconds", lap.TotalTimeSeconds);
+        this.addOptionalNumericElement(parts, "DistanceMeters", lap.DistanceMeters);
+        this.addOptionalNumericElement(parts, "MaximumSpeed", lap.MaximumSpeed);
+        this.addOptionalNumericElement(parts, "Calories", lap.Calories);
+        // 心率
+        if (lap.AverageHeartRateBpm) {
+            parts.push(`<AverageHeartRateBpm xsi:type="HeartRateInBeatsPerMinute_t"><Value>${lap.AverageHeartRateBpm}</Value></AverageHeartRateBpm>`);
+        }
+        if (lap.MaximumHeartRateBpm) {
+            parts.push(`<MaximumHeartRateBpm xsi:type="HeartRateInBeatsPerMinute_t"><Value>${lap.MaximumHeartRateBpm}</Value></MaximumHeartRateBpm>`);
+        }
+        // 其他属性
+        this.addOptionalElement(parts, "Intensity", lap.Intensity);
+        if (lap.Cadence) {
+            parts.push(this.buildCadence(lap.Cadence));
+        }
+        this.addOptionalElement(parts, "TriggerMethod", lap.TriggerMethod);
+        // Track 数据
+        if (lap.Track) {
+            lap.Track.forEach((track) => {
+                parts.push(this.buildTrack(track));
+            });
+        }
+        this.addOptionalElement(parts, "Notes", lap.Notes);
+        if (lap.Extensions) {
+            parts.push(this.buildExtensions(lap.Extensions));
+        }
+        parts.push("</Lap>");
+        return parts.join("\n      ");
+    }
+    /**
+     * 构建 Track 元素
+     */
+    buildTrack(track) {
+        const parts = ["<Track>"];
+        if (track.Trackpoint) {
+            track.Trackpoint.forEach((trackpoint) => {
+                parts.push(this.buildTrackpoint(trackpoint));
+            });
+        }
+        parts.push("</Track>");
+        return parts.join("\n        ");
+    }
+    /**
+     * 构建 Trackpoint 元素
+     */
+    buildTrackpoint(trackpoint) {
+        const parts = ["<Trackpoint>"];
+        // 时间（通常是必需的）
+        if (trackpoint.Time) {
+            parts.push(`<Time>${this.formatTime(trackpoint.Time)}</Time>`);
+        }
+        // 位置
+        if (trackpoint.Position) {
+            parts.push(this.buildPosition(trackpoint.Position));
+        }
+        // 数值属性
+        this.addOptionalNumericElement(parts, "AltitudeMeters", trackpoint.AltitudeMeters);
+        this.addOptionalNumericElement(parts, "DistanceMeters", trackpoint.DistanceMeters);
+        // 心率
+        if (trackpoint.HeartRateBpm) {
+            parts.push(`<HeartRateBpm xsi:type="HeartRateInBeatsPerMinute_t"><Value>${trackpoint.HeartRateBpm}</Value></HeartRateBpm>`);
+        }
+        // 踏频
+        if (trackpoint.Cadence) {
+            parts.push(this.buildCadence(trackpoint.Cadence));
+        }
+        // 传感器状态
+        this.addOptionalElement(parts, "SensorState", trackpoint.SensorState);
+        // 扩展
+        if (trackpoint.Extensions) {
+            parts.push(this.buildExtensions(trackpoint.Extensions));
+        }
+        parts.push("</Trackpoint>");
+        return parts.join("\n          ");
+    }
+    /**
+     * 构建 Position 元素
+     */
+    buildPosition(position) {
+        const parts = ["<Position>"];
+        if (position.LatitudeDegrees) {
+            parts.push(`<LatitudeDegrees>${this.formatCoordinate(parseFloat(position.LatitudeDegrees))}</LatitudeDegrees>`);
+        }
+        if (position.LongitudeDegrees) {
+            parts.push(`<LongitudeDegrees>${this.formatCoordinate(parseFloat(position.LongitudeDegrees))}</LongitudeDegrees>`);
+        }
+        parts.push("</Position>");
+        return parts.join("");
+    }
+    /**
+     * 构建 Cadence 元素
+     */
+    buildCadence(cadence) {
+        return `<Cadence><Low>${cadence.Low}</Low><High>${cadence.High}</High></Cadence>`;
+    }
+    /**
+     * 构建 MultiSportSession 元素
+     */
+    buildMultiSportSession(session) {
+        const parts = ["<MultiSportSession>"];
+        if (session.Id) {
+            parts.push(`<Id>${this.formatTime(session.Id)}</Id>`);
+        }
+        if (session.FirstSport) {
+            parts.push(this.buildFirstSport(session.FirstSport));
+        }
+        if (session.NextSport) {
+            session.NextSport.forEach((nextSport) => {
+                parts.push(this.buildNextSport(nextSport));
+            });
+        }
+        this.addOptionalElement(parts, "Notes", session.Notes);
+        parts.push("</MultiSportSession>");
+        return parts.join("\n    ");
+    }
+    /**
+     * 构建 FirstSport 元素
+     */
+    buildFirstSport(firstSport) {
+        const parts = ["<FirstSport>"];
+        if (firstSport.Activity) {
+            parts.push(this.buildActivity(firstSport.Activity));
+        }
+        parts.push("</FirstSport>");
+        return parts.join("\n      ");
+    }
+    /**
+     * 构建 NextSport 元素
+     */
+    buildNextSport(nextSport) {
+        const parts = ["<NextSport>"];
+        if (nextSport.Transition) {
+            // Transition 使用 ActivityLap 结构
+            parts.push(`<Transition>${this.buildActivityLap(nextSport.Transition)}</Transition>`);
+        }
+        if (nextSport.Activity) {
+            parts.push(this.buildActivity(nextSport.Activity));
+        }
+        parts.push("</NextSport>");
+        return parts.join("\n      ");
+    }
+    /**
+     * 构建 Workouts 元素
+     */
+    buildWorkouts(workouts) {
+        // TODO: 实现 Workouts 构建
+        console.warn("Workouts 构建暂未实现");
+        return "<Workouts></Workouts>";
+    }
+    /**
+     * 构建 Courses 元素
+     */
+    buildCourses(courses) {
+        // TODO: 实现 Courses 构建
+        console.warn("Courses 构建暂未实现");
+        return "<Courses></Courses>";
+    }
+    /**
+     * 构建 Author 元素
+     */
+    buildAuthor(author) {
+        const parts = ["<Author>"];
+        this.addOptionalElement(parts, "Name", author.Name);
+        parts.push("</Author>");
+        return parts.join("");
+    }
+    // ==================== 扩展处理 ====================
+    /**
+     * 构建扩展元素
+     */
+    buildExtensions(extensions) {
+        const content = this.buildExtensionContent(extensions);
+        return content ? `<Extensions>${content}</Extensions>` : "";
+    }
+    /**
+     * 递归构建扩展内容
+     */
+    buildExtensionContent(extension) {
+        return Object.entries(extension)
+            .filter(([key]) => !key.startsWith("xmlns"))
+            .map(([key, value]) => {
+            if (value && typeof value === "object") {
+                const content = this.buildExtensionContent(value);
+                return `<${key}>${content}</${key}>`;
+            }
+            else if (value !== undefined && value !== null) {
+                return `<${key}>${this.escapeXML(String(value))}</${key}>`;
+            }
+            return "";
+        })
+            .filter((content) => content)
+            .join("");
+    }
+    // ==================== 辅助方法 ====================
+    /**
+     * 格式化时间
+     */
+    formatTime(time) {
+        // 如果是字符串且已经是正确的ISO格式，直接使用
+        if (typeof time === "string") {
+            // 检查是否已经是标准的ISO 8601格式
+            if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(time)) {
+                return time;
+            }
+        }
+        // 对于Date对象或其他格式的字符串，使用dayjs处理
+        return dayjs(time).utc().format("YYYY-MM-DDTHH:mm:ss[Z]");
+    }
+    /**
+     * 添加可选元素
+     */
+    addOptionalElement(parts, tagName, value, formatter) {
+        if (value !== undefined && value !== null && value !== "") {
+            const formattedValue = formatter
+                ? formatter(value)
+                : this.escapeXML(value);
+            parts.push(`<${tagName}>${formattedValue}</${tagName}>`);
+        }
+    }
+    /**
+     * 添加可选数值元素
+     */
+    addOptionalNumericElement(parts, tagName, value) {
+        if (value !== undefined && value !== null && !isNaN(value)) {
+            parts.push(`<${tagName}>${value}</${tagName}>`);
+        }
+    }
+    /**
+     * 验证坐标有效性
+     */
+    isValidCoordinate(lat, lon) {
+        return (lat !== undefined &&
+            lat !== null &&
+            lon !== undefined &&
+            lon !== null &&
+            !isNaN(lat) &&
+            !isNaN(lon));
+    }
+    /**
+     * 格式化坐标
+     */
+    formatCoordinate(coord) {
+        return this.roundTo(coord, 6).toString();
+    }
+    /**
+     * 数字四舍五入
+     */
+    roundTo(num, precision) {
+        const factor = Math.pow(10, precision);
+        return Math.round(num * factor) / factor;
+    }
+    /**
+     * XML 转义
+     */
+    escapeXML(text) {
+        return text
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/"/g, "&quot;")
+            .replace(/'/g, "&apos;");
+    }
+    /**
+     * XML 属性值转义（专门用于属性值的安全转义）
+     */
+    escapeXMLAttribute(text) {
+        if (typeof text !== "string") {
+            return String(text || "");
+        }
+        return text
+            .replace(/&/g, "&amp;")
+            .replace(/"/g, "&quot;")
+            .replace(/'/g, "&apos;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/\r/g, "&#13;")
+            .replace(/\n/g, "&#10;")
+            .replace(/\t/g, "&#9;");
+    }
+    /**
+     * 深度拷贝
+     */
+    deepClone(obj) {
+        if (obj === null || typeof obj !== "object") {
+            return obj;
+        }
+        if (obj instanceof Date) {
+            return new Date(obj.getTime());
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => this.deepClone(item));
+        }
+        const cloned = {};
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                cloned[key] = this.deepClone(obj[key]);
+            }
+        }
+        return cloned;
+    }
+    // ==================== 向后兼容 ====================
+    /**
+     * @deprecated 使用 encode() 替代
+     */
+    encoder(node) {
+        return this.encode(node);
+    }
+}

package/dist/TCX/index.d.ts

@@ -0,0 +1,10 @@
+export { TCXDecoder } from "./decoder.js";
+export { TCXFileType, TCXContext } from "./types.js";
+export { AstGenerateProcessor, CompleteProcessor, ConvertProcessor, IPipelineProcessor, TokenizeProcessor, PipelineStage, } from "./processor.js";
+export * from "./base.js";
+export * from "./converters.js";
+import { TCXDecoder } from "./decoder.js";
+declare const _default: {
+    TCXDecoder: typeof TCXDecoder;
+};
+export default _default;

package/dist/TCX/index.js

@@ -0,0 +1,9 @@
+// ============ 核心类和接口 ============
+export { TCXDecoder } from "./decoder.js";
+export { AstGenerateProcessor, CompleteProcessor, ConvertProcessor, TokenizeProcessor, PipelineStage, } from "./processor.js";
+// ============ 基础架构 ============
+export * from "./base.js";
+// ============ 转换器 ============
+export * from "./converters.js";
+import { TCXDecoder } from "./decoder.js";
+export default { TCXDecoder };

package/dist/TCX/middleware.d.ts

@@ -0,0 +1,27 @@
+import { Token, TokenAST } from "../types.js";
+import { BaseTCXMiddleware } from "./base.js";
+import { TCXContext } from "./types.js";
+/**
+ * 性能监控中间件
+ */
+export declare class PerformanceMiddleware extends BaseTCXMiddleware {
+    name: string;
+    description: string;
+    onTokenize(tokens: Token[], context: TCXContext): Promise<Token[]>;
+    onAstGenerate(ast: TokenAST, context: TCXContext): Promise<TokenAST>;
+    onComplete(result: any, context: TCXContext): Promise<any>;
+    private countNodes;
+}
+/**
+ * 验证中间件
+ */
+export declare class ValidationMiddleware extends BaseTCXMiddleware {
+    name: string;
+    description: string;
+    onComplete(result: any, context: TCXContext): Promise<any>;
+    private validateGPX;
+}
+/**
+ * 注册所有默认中间件
+ */
+export declare function registerDefaultMiddlewares(decoder: any): Promise<void>;

package/dist/TCX/middleware.js

@@ -0,0 +1,93 @@
+import { BaseTCXMiddleware } from "./base.js";
+// ============ 示例中间件 ============
+/**
+ * 性能监控中间件
+ */
+export class PerformanceMiddleware extends BaseTCXMiddleware {
+    constructor() {
+        super(...arguments);
+        this.name = "performance-middleware";
+        this.description = "监控解析性能";
+    }
+    async onTokenize(tokens, context) {
+        console.log(`Token化完成，生成了 ${tokens.length} 个token`);
+        return tokens;
+    }
+    async onAstGenerate(ast, context) {
+        const nodeCount = this.countNodes(ast);
+        console.log(`AST生成完成，包含 ${nodeCount} 个节点`);
+        return ast;
+    }
+    async onComplete(result, context) {
+        const performance = context.metadata.get("performance");
+        console.log("解析性能统计:", performance);
+        return result;
+    }
+    countNodes(ast) {
+        let count = 1;
+        if (ast.children) {
+            for (const child of ast.children) {
+                count += this.countNodes(child);
+            }
+        }
+        return count;
+    }
+}
+/**
+ * 验证中间件
+ */
+export class ValidationMiddleware extends BaseTCXMiddleware {
+    constructor() {
+        super(...arguments);
+        this.name = "validation-middleware";
+        this.description = "验证GPX数据的完整性";
+    }
+    async onComplete(result, context) {
+        const errors = this.validateGPX(result);
+        if (errors.length > 0) {
+            console.warn("GPX验证发现问题:", errors);
+            context.metadata.set("validation-errors", errors);
+        }
+        else {
+            console.log("GPX验证通过");
+        }
+        return result;
+    }
+    validateGPX(gpx) {
+        const errors = [];
+        if (!gpx.version) {
+            errors.push("缺少GPX版本信息");
+        }
+        if (!gpx.creator) {
+            errors.push("缺少GPX创建者信息");
+        }
+        // 验证轨迹点
+        if (gpx.trk) {
+            for (const track of gpx.trk) {
+                if (track.trkseg) {
+                    for (const segment of track.trkseg) {
+                        if (segment.trkpt) {
+                            for (const point of segment.trkpt) {
+                                if (typeof point.lat !== "number" ||
+                                    typeof point.lon !== "number") {
+                                    errors.push("轨迹点坐标无效");
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return errors;
+    }
+}
+// ============ 默认转换器注册函数 ============
+/**
+ * 注册所有默认中间件
+ */
+export async function registerDefaultMiddlewares(decoder) {
+    const middlewares = [new PerformanceMiddleware(), new ValidationMiddleware()];
+    for (const middleware of middlewares) {
+        await decoder.registerMiddleware(middleware);
+    }
+}