trackswap 0.0.2 → 0.0.3

package/dist/GPX/processor.js

@@ -1,188 +0,0 @@
-import { Parser } from "htmlparser2";
-/**
- * 流水线阶段
- */
-export var PipelineStage;
-(function (PipelineStage) {
-    PipelineStage["TOKENIZE"] = "tokenize";
-    PipelineStage["AST_GENERATE"] = "ast_generate";
-    PipelineStage["CONVERT"] = "convert";
-    PipelineStage["COMPLETE"] = "complete";
-})(PipelineStage || (PipelineStage = {}));
-/**
- * Tokenize处理器, 将xml转为 token
- */
-export class TokenizeProcessor {
-    constructor() {
-        this.stage = PipelineStage.TOKENIZE;
-    }
-    async process(context) {
-        const startTime = Date.now();
-        if (!context.xmlContent) {
-            throw new Error("XML内容不能为空");
-        }
-        const tokens = [];
-        const parser = new Parser({
-            onopentag(name, attribs) {
-                tokens.push({
-                    type: "open",
-                    tag: name,
-                    attributes: attribs,
-                });
-            },
-            ontext(text) {
-                const filteredText = text.replace(/\n/g, "").trim();
-                if (filteredText) {
-                    tokens.push({ type: "text", tag: "text", value: filteredText });
-                }
-            },
-            onclosetag(name) {
-                tokens.push({ type: "close", tag: name });
-            },
-        }, { xmlMode: true });
-        parser.write(context.xmlContent);
-        parser.end();
-        context.tokens = tokens;
-        context.performance.tokenizeTime = Date.now() - startTime;
-        return context;
-    }
-}
-/**
- * AST生成处理器
- */
-export class AstGenerateProcessor {
-    constructor() {
-        this.stage = PipelineStage.AST_GENERATE;
-    }
-    async process(context) {
-        const startTime = Date.now();
-        if (!context.tokens) {
-            throw new Error("Tokens不能为空");
-        }
-        const stack = [];
-        let root = undefined;
-        let current = null;
-        for (const token of context.tokens) {
-            if (token.type === "open") {
-                const newElement = {
-                    tag: token.tag,
-                    attributes: token.attributes || {},
-                    children: [],
-                };
-                if (!root) {
-                    root = newElement;
-                }
-                else if (current) {
-                    current.children?.push(newElement);
-                }
-                stack.push(newElement);
-                current = newElement;
-            }
-            else if (token.type === "text" && current) {
-                current.value = token.value;
-            }
-            else if (token.type === "close") {
-                stack.pop();
-                current = stack[stack.length - 1] || null;
-            }
-        }
-        context.ast = root;
-        context.performance.astTime = Date.now() - startTime;
-        return context;
-    }
-}
-/**
- * 转换处理器
- */
-export class ConvertProcessor {
-    constructor(getConverter) {
-        this.getConverter = getConverter;
-        this.stage = PipelineStage.CONVERT;
-    }
-    async process(context) {
-        const startTime = Date.now();
-        if (!context.ast) {
-            throw new Error("AST不能为空");
-        }
-        const gpx = {};
-        // 处理根节点属性
-        if (context.ast.attributes) {
-            Object.entries(context.ast.attributes).forEach(([key, value]) => {
-                if (key.startsWith("xmlns:")) {
-                    gpx[key] = value.replace(/'/g, "'");
-                }
-                else if (key === "xsi:schemaLocation") {
-                    gpx[key] = value.replace(/'/g, "'");
-                }
-                else {
-                    gpx[key] = value;
-                }
-            });
-        }
-        // 处理子节点
-        context.ast.children?.forEach((child) => {
-            const converter = this.getConverter(child.tag);
-            if (!converter) {
-                console.error(`标签 ${child.tag} 未找到对应的 converter`);
-            }
-            try {
-                const result = converter.convert(child, context);
-                if (result) {
-                    this.assignResult(gpx, child.tag, result);
-                }
-            }
-            catch (error) {
-                context.errors.push(error);
-                console.error(`转换器 ${converter.name} 处理标签 ${child.tag} 时出错:`, error);
-            }
-        });
-        context.result = gpx;
-        context.performance.convertTime = Date.now() - startTime;
-        return context;
-    }
-    assignResult(gpx, tag, result) {
-        switch (tag) {
-            case "metadata":
-                gpx.metadata = result;
-                break;
-            case "wpt":
-                if (!gpx.wpt)
-                    gpx.wpt = [];
-                gpx.wpt.push(result);
-                break;
-            case "rte":
-                if (!gpx.rte)
-                    gpx.rte = [];
-                gpx.rte.push(result);
-                break;
-            case "trk":
-                if (!gpx.trk)
-                    gpx.trk = [];
-                gpx.trk.push(result);
-                break;
-            case "extensions":
-                gpx.extensions = result;
-                break;
-        }
-    }
-}
-/**
- * 完成处理器
- */
-export class CompleteProcessor {
-    constructor() {
-        this.stage = PipelineStage.COMPLETE;
-    }
-    async process(context) {
-        context.performance.endTime = Date.now();
-        // 记录性能指标
-        const totalTime = context.performance.endTime - context.performance.startTime;
-        context.metadata.set("performance", {
-            totalTime,
-            tokenizeTime: context.performance.tokenizeTime,
-            astTime: context.performance.astTime,
-            convertTime: context.performance.convertTime,
-        });
-        return context;
-    }
-}

package/dist/GPX/types.js

@@ -1 +0,0 @@
-export {};

package/dist/GPX/util.js

@@ -1,18 +0,0 @@
-export const GPXWPTOriginKey = [
-    'magvar',
-    'geoidheight',
-    'name',
-    'cmt',
-    'src',
-    'link',
-    'sym',
-    'type',
-    'fix',
-    'sat',
-    'desc',
-    'hdop',
-    'vdop',
-    'pdop',
-    'ageofdgpsdata',
-    'dgpsid',
-];

package/dist/TCX/base.js

@@ -1,62 +0,0 @@
-import { BaseConverter, BaseMiddleware, } from "../core/base.js";
-// ============ TCX 特定基础类 ============
-/**
- * TCX 基础转换器抽象类（继承通用基础转换器）
- */
-export class BaseTCXConverter extends BaseConverter {
-    // TCX 特定的工具方法可以在这里添加
-    /**
-     * 解析 TCX 心率值
-     */
-    parseHeartRate(value) {
-        const hr = this.parseFloat(value);
-        return hr > 0 && hr < 300 ? hr : undefined; // 合理的心率范围
-    }
-    /**
-     * 解析 TCX 时间格式（ISO 8601）
-     */
-    parseTCXTime(value) {
-        if (!value)
-            return undefined;
-        // TCX 使用 ISO 8601 格式
-        const date = new Date(value);
-        return isNaN(date.getTime()) ? undefined : date;
-    }
-    /**
-     * 解析 TCX 距离值（米）
-     */
-    parseDistance(value) {
-        const distance = this.parseFloat(value);
-        return distance >= 0 ? distance : undefined;
-    }
-    /**
-     * 解析 TCX 速度值（m/s）
-     */
-    parseSpeed(value) {
-        const speed = this.parseFloat(value);
-        return speed >= 0 ? speed : undefined;
-    }
-    /**
-     * 解析 TCX 海拔值（米）
-     */
-    parseAltitude(value) {
-        return this.parseFloat(value);
-    }
-    /**
-     * 解析 TCX 坐标值（纬度/经度）
-     */
-    parseCoordinate(value) {
-        const coord = this.parseFloat(value);
-        return coord !== 0 ? coord : undefined;
-    }
-}
-/**
- * TCX 基础中间件抽象类（继承通用基础中间件）
- */
-export class BaseTCXMiddleware extends BaseMiddleware {
-    // TCX 特定的中间件逻辑可以在这里添加
-    async onError(error, context) {
-        console.error(`TCX中间件 ${this.name} 处理错误:`, error);
-        context.warnings.push(`中间件 ${this.name} 错误: ${error.message}`);
-    }
-}

package/dist/TCX/converters.js

@@ -1,333 +0,0 @@
-import { BaseTCXConverter } from "./base.js";
-// ============ 基础元素转换器 ============
-/**
- * 位置转换器
- */
-export class PositionConverter extends BaseTCXConverter {
-    constructor() {
-        super(...arguments);
-        this.name = "PositionConverter";
-        this.supportedTags = ["Position"];
-    }
-    convert(ast, context) {
-        const position = {};
-        this.processChildren(ast, position, {
-            LatitudeDegrees: (child, target) => (target.LatitudeDegrees = this.parseString(child.value)),
-            LongitudeDegrees: (child, target) => (target.LongitudeDegrees = this.parseString(child.value)),
-        });
-        return position;
-    }
-}
-/**
- * 轨迹点转换器
- */
-export class TrackpointConverter extends BaseTCXConverter {
-    constructor() {
-        super(...arguments);
-        this.name = "TrackpointConverter";
-        this.supportedTags = ["Trackpoint"];
-    }
-    convert(ast, context) {
-        const trackpoint = {};
-        this.processChildren(ast, trackpoint, {
-            Time: (child, target) => (target.Time = this.parseString(child.value)),
-            Position: (child, target) => {
-                const decoder = context.metadata.get("decoder");
-                target.Position = decoder
-                    ?.getConverter("Position")
-                    ?.convert(child, context);
-            },
-            AltitudeMeters: (child, target) => (target.AltitudeMeters = this.parseFloat(child.value)),
-            DistanceMeters: (child, target) => (target.DistanceMeters = this.parseFloat(child.value)),
-            HeartRateBpm: (child, target) => {
-                // 处理两种格式：<HeartRateBpm>123</HeartRateBpm> 或 <HeartRateBpm><Value>123</Value></HeartRateBpm>
-                if (child.value) {
-                    target.HeartRateBpm = this.parseFloat(child.value);
-                }
-                else {
-                    const valueChild = this.getChildByTag(child, "Value");
-                    if (valueChild?.value) {
-                        target.HeartRateBpm = this.parseFloat(valueChild.value);
-                    }
-                }
-            },
-            Cadence: (child, target) => {
-                const cadence = { Low: 0, High: 0 };
-                this.processChildren(child, cadence, {
-                    Low: (subChild, subTarget) => (subTarget.Low = this.parseFloat(subChild.value)),
-                    High: (subChild, subTarget) => (subTarget.High = this.parseFloat(subChild.value)),
-                });
-                target.Cadence = cadence;
-            },
-            SensorState: (child, target) => (target.SensorState = child.value),
-            Extensions: (child, target) => (target.Extensions = this.convertExtensions(child)),
-        });
-        return trackpoint;
-    }
-    convertExtensions(extensionsAST) {
-        const extensions = {};
-        extensionsAST.children?.forEach((child) => {
-            extensions[child.tag] = this.convertExtensionContent(child);
-        });
-        return extensions;
-    }
-    convertExtensionContent(extension) {
-        if (extension.children?.length) {
-            const result = {};
-            extension.children.forEach((child) => {
-                result[child.tag] = this.convertExtensionContent(child);
-            });
-            return result;
-        }
-        else {
-            return extension.value;
-        }
-    }
-}
-/**
- * 轨迹转换器
- */
-export class TrackConverter extends BaseTCXConverter {
-    constructor() {
-        super(...arguments);
-        this.name = "TrackConverter";
-        this.supportedTags = ["Track"];
-    }
-    convert(ast, context) {
-        const track = {
-            Trackpoint: [],
-        };
-        this.processChildren(ast, track, {
-            Trackpoint: (child, target) => {
-                const decoder = context.metadata.get("decoder");
-                const trackpoint = decoder
-                    ?.getConverter("Trackpoint")
-                    ?.convert(child, context);
-                if (trackpoint && target.Trackpoint) {
-                    target.Trackpoint.push(trackpoint);
-                }
-            },
-        });
-        return track;
-    }
-}
-/**
- * 活动圈数转换器
- */
-export class ActivityLapConverter extends BaseTCXConverter {
-    constructor() {
-        super(...arguments);
-        this.name = "ActivityLapConverter";
-        this.supportedTags = ["Lap"];
-    }
-    convert(ast, context) {
-        const lap = {};
-        // 提取属性
-        this.extractAttributes(ast, lap, {
-            StartTime: "Id",
-        });
-        this.processChildren(ast, lap, {
-            TotalTimeSeconds: (child, target) => (target.TotalTimeSeconds = this.parseFloat(child.value)),
-            DistanceMeters: (child, target) => (target.DistanceMeters = this.parseFloat(child.value)),
-            MaximumSpeed: (child, target) => (target.MaximumSpeed = this.parseFloat(child.value)),
-            Calories: (child, target) => (target.Calories = this.parseFloat(child.value)),
-            AverageHeartRateBpm: (child, target) => (target.AverageHeartRateBpm = this.parseFloat(child.value)),
-            MaximumHeartRateBpm: (child, target) => (target.MaximumHeartRateBpm = this.parseFloat(child.value)),
-            Intensity: (child, target) => (target.Intensity = child.value),
-            TriggerMethod: (child, target) => (target.TriggerMethod = child.value),
-            Track: (child, target) => {
-                if (!target.Track)
-                    target.Track = [];
-                const decoder = context.metadata.get("decoder");
-                const track = decoder?.getConverter("Track")?.convert(child, context);
-                if (track)
-                    target.Track.push(track);
-            },
-            Notes: (child, target) => (target.Notes = this.parseString(child.value)),
-            Extensions: (child, target) => (target.Extensions = this.convertExtensions(child)),
-        });
-        return lap;
-    }
-    convertExtensions(extensionsAST) {
-        const extensions = {};
-        extensionsAST.children?.forEach((child) => {
-            extensions[child.tag] = this.convertExtensionContent(child);
-        });
-        return extensions;
-    }
-    convertExtensionContent(extension) {
-        if (extension.children?.length) {
-            const result = {};
-            extension.children.forEach((child) => {
-                result[child.tag] = this.convertExtensionContent(child);
-            });
-            return result;
-        }
-        else {
-            return extension.value;
-        }
-    }
-}
-/**
- * 活动转换器
- */
-export class ActivityConverter extends BaseTCXConverter {
-    constructor() {
-        super(...arguments);
-        this.name = "ActivityConverter";
-        this.supportedTags = ["Activity"];
-    }
-    convert(ast, context) {
-        const activity = {
-            Id: "",
-            Lap: [],
-        };
-        // 提取属性
-        this.extractAttributes(ast, activity, {
-            Sport: "Sport",
-        });
-        this.processChildren(ast, activity, {
-            Id: (child, target) => (target.Id = this.parseString(child.value)),
-            Lap: (child, target) => {
-                const decoder = context.metadata.get("decoder");
-                const lap = decoder?.getConverter("Lap")?.convert(child, context);
-                if (lap)
-                    target.Lap.push(lap);
-            },
-            Notes: (child, target) => (target.Notes = this.parseString(child.value)),
-            Training: (child, target) => (target.Training = this.convertTraining(child)),
-            Creator: (child, target) => (target.Creator = this.convertCreator(child)),
-            Extensions: (child, target) => (target.Extensions = this.convertExtensions(child)),
-        });
-        return activity;
-    }
-    convertTraining(ast) {
-        const training = {};
-        // 处理属性
-        if (ast.attributes) {
-            Object.entries(ast.attributes).forEach(([key, value]) => {
-                training[key] = value;
-            });
-        }
-        // 处理子元素
-        ast.children?.forEach((child) => {
-            training[child.tag] = this.convertExtensionContent(child);
-        });
-        return training;
-    }
-    convertCreator(ast) {
-        const creator = {};
-        ast.children?.forEach((child) => {
-            creator[child.tag] = this.convertExtensionContent(child);
-        });
-        return creator;
-    }
-    convertExtensions(extensionsAST) {
-        const extensions = {};
-        extensionsAST.children?.forEach((child) => {
-            extensions[child.tag] = this.convertExtensionContent(child);
-        });
-        return extensions;
-    }
-    convertExtensionContent(extension) {
-        if (extension.children?.length) {
-            const result = {};
-            extension.children.forEach((child) => {
-                result[child.tag] = this.convertExtensionContent(child);
-            });
-            return result;
-        }
-        else {
-            return extension.value;
-        }
-    }
-}
-/**
- * 活动列表转换器
- */
-export class ActivityListConverter extends BaseTCXConverter {
-    constructor() {
-        super(...arguments);
-        this.name = "ActivityListConverter";
-        this.supportedTags = ["Activities"];
-    }
-    convert(ast, context) {
-        const activities = {
-            Activity: [],
-            MultiSportSession: [],
-        };
-        this.processChildren(ast, activities, {
-            Activity: (child, target) => {
-                const decoder = context.metadata.get("decoder");
-                const activity = decoder
-                    ?.getConverter("Activity")
-                    ?.convert(child, context);
-                if (activity && target.Activity) {
-                    target.Activity.push(activity);
-                }
-            },
-            MultiSportSession: (child, target) => {
-                const decoder = context.metadata.get("decoder");
-                const session = decoder
-                    ?.getConverter("MultiSportSession")
-                    ?.convert(child, context);
-                if (session && target.MultiSportSession) {
-                    target.MultiSportSession.push(session);
-                }
-            },
-        });
-        return activities;
-    }
-}
-/**
- * 多运动会话转换器
- */
-export class MultiSportSessionConverter extends BaseTCXConverter {
-    constructor() {
-        super(...arguments);
-        this.name = "MultiSportSessionConverter";
-        this.supportedTags = ["MultiSportSession"];
-    }
-    convert(ast, context) {
-        const session = {};
-        this.processChildren(ast, session, {
-            Id: (child, target) => (target.Id = this.parseString(child.value)),
-            FirstSport: (child, target) => {
-                const decoder = context.metadata.get("decoder");
-                target.FirstSport = decoder
-                    ?.getConverter("FirstSport")
-                    ?.convert(child, context);
-            },
-            NextSport: (child, target) => {
-                if (!target.NextSport)
-                    target.NextSport = [];
-                const decoder = context.metadata.get("decoder");
-                const nextSport = decoder
-                    ?.getConverter("NextSport")
-                    ?.convert(child, context);
-                if (nextSport)
-                    target.NextSport.push(nextSport);
-            },
-            Notes: (child, target) => (target.Notes = this.parseString(child.value)),
-        });
-        return session;
-    }
-}
-// ============ 辅助转换器 ============
-/**
- * 抽象来源转换器
- */
-export class AbstractSourceConverter extends BaseTCXConverter {
-    constructor() {
-        super(...arguments);
-        this.name = "AbstractSourceConverter";
-        this.supportedTags = ["Author", "Creator"];
-    }
-    convert(ast, context) {
-        const source = {};
-        this.processChildren(ast, source, {
-            Name: (child, target) => (target.Name = this.parseString(child.value)),
-        });
-        return source;
-    }
-}