trackswap 0.0.1 → 0.0.2

package/dist/TCX/converters.js

@@ -0,0 +1,333 @@
+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;
+    }
+}

package/dist/TCX/decoder.d.ts

@@ -0,0 +1,87 @@
+import { ExtensionsType, TokenAST } from "../types.js";
+import { ITCXConverterPlugin, ITCXMiddlewarePlugin } from "./base.js";
+import { TCXFileType } from "./types.js";
+/**
+ * https://www8.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd
+ */
+export declare class TCXDecoder {
+    private converterPlugins;
+    private registeredPlugins;
+    private middlewarePlugins;
+    private processors;
+    private initialized;
+    private defaultConvertersRegistered;
+    constructor();
+    /**
+     * 初始化流水线 - 注册固定的核心处理器
+     */
+    private initializePipeline;
+    /**
+     * 自动注册默认转换器 - 处理标准TCX标签
+     */
+    private registerDefaultConverters;
+    /**
+     * 为指定标签添加转换器，按优先级排序
+     */
+    private addConverterForTag;
+    /**
+     * 注册转换器插件
+     */
+    registerConverter(plugin: ITCXConverterPlugin): Promise<void>;
+    /**
+     * 注册中间件插件 - 真正的扩展点
+     */
+    registerMiddleware(plugin: ITCXMiddlewarePlugin): Promise<void>;
+    /**
+     * 获取转换器（返回优先级最高的）
+     */
+    getConverter(tag: string): ITCXConverterPlugin | undefined;
+    /**
+     * 获取指定标签的所有转换器（按优先级排序）
+     */
+    getAllConverters(tag: string): ITCXConverterPlugin[];
+    /**
+     * 移除转换器
+     */
+    unregisterConverter(pluginName: string): void;
+    /**
+     * 移除中间件
+     */
+    unregisterMiddleware(name: string): void;
+    /**
+     * 初始化解码器
+     */
+    initialize(): Promise<void>;
+    /**
+     * 销毁解码器
+     */
+    destroy(): Promise<void>;
+    /**
+     * 创建解码上下文
+     */
+    private createContext;
+    /**
+     * 执行中间件钩子
+     */
+    private executeMiddlewareHook;
+    /**
+     * 主解析方法 - 固定的流水线 + 灵活的中间件
+     */
+    parseByBuffer(buffer: Buffer): Promise<TCXFileType | undefined>;
+    /**
+     * 转换Extensions（向后兼容）
+     */
+    convertExtensions(extensionsAST: TokenAST): ExtensionsType;
+    /**
+     * @deprecated 使用 parseByBuffer 替代
+     */
+    parserByBuffer(buffer: Buffer): Promise<TCXFileType | undefined>;
+    /**
+     * @deprecated 使用新的插件系统替代
+     */
+    parseByString(xmlContent: string): Promise<TCXFileType | undefined>;
+}
+declare const _default: {
+    TCXDecoder: typeof TCXDecoder;
+};
+export default _default;