trackswap 0.0.1 → 0.0.2

package/dist/TCX/processor.d.ts

@@ -0,0 +1,48 @@
+import { TCXContext } from "./types.js";
+/**
+ * 流水线阶段
+ */
+export declare enum PipelineStage {
+    TOKENIZE = "tokenize",
+    AST_GENERATE = "ast_generate",
+    CONVERT = "convert",
+    COMPLETE = "complete"
+}
+/**
+ * 流水线处理器接口
+ */
+export interface IPipelineProcessor {
+    stage: PipelineStage;
+    process(context: TCXContext): Promise<TCXContext>;
+}
+/**
+ * Tokenize处理器，将XML转为Token
+ */
+export declare class TokenizeProcessor implements IPipelineProcessor {
+    stage: PipelineStage;
+    process(context: TCXContext): Promise<TCXContext>;
+}
+/**
+ * AST生成处理器
+ */
+export declare class AstGenerateProcessor implements IPipelineProcessor {
+    stage: PipelineStage;
+    process(context: TCXContext): Promise<TCXContext>;
+}
+/**
+ * 转换处理器
+ */
+export declare class ConvertProcessor implements IPipelineProcessor {
+    private getConverter;
+    stage: PipelineStage;
+    constructor(getConverter: (tag: string) => any);
+    process(context: TCXContext): Promise<TCXContext>;
+    private assignResult;
+}
+/**
+ * 完成处理器
+ */
+export declare class CompleteProcessor implements IPipelineProcessor {
+    stage: PipelineStage;
+    process(context: TCXContext): Promise<TCXContext>;
+}

package/dist/TCX/processor.js

@@ -0,0 +1,197 @@
+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 tcx = {};
+        // 处理根节点属性
+        if (context.ast.attributes) {
+            Object.entries(context.ast.attributes).forEach(([key, value]) => {
+                if (key.startsWith("xmlns:")) {
+                    tcx[key] = value.replace(/'/g, "'");
+                }
+                else if (key === "xsi:schemaLocation") {
+                    tcx[key] = value.replace(/'/g, "'");
+                }
+                else {
+                    tcx[key] = value;
+                }
+            });
+        }
+        // 处理子节点
+        context.ast.children?.forEach((child) => {
+            const converter = this.getConverter(child.tag);
+            if (!converter) {
+                console.error(`标签 ${child.tag} 未找到对应的 converter`);
+                return;
+            }
+            try {
+                const result = converter.convert(child, context);
+                if (result) {
+                    this.assignResult(tcx, child.tag, result);
+                }
+            }
+            catch (error) {
+                context.errors.push(error);
+                console.error(`转换器 ${converter.name} 处理标签 ${child.tag} 时出错:`, error);
+            }
+        });
+        context.result = tcx;
+        context.performance.convertTime = Date.now() - startTime;
+        return context;
+    }
+    assignResult(tcx, tag, result) {
+        switch (tag) {
+            case "Folders":
+                tcx.Folders = result;
+                break;
+            case "Activities":
+                tcx.Activities = result;
+                break;
+            case "Workouts":
+                tcx.Workouts = result;
+                break;
+            case "Courses":
+                tcx.Courses = result;
+                break;
+            case "Author":
+                tcx.Author = result;
+                break;
+            case "Extensions":
+                tcx.Extensions = result;
+                break;
+            default:
+                // 对于其他标签，直接赋值
+                tcx[tag] = 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,
+        });
+        // 更新统计信息
+        if (context.stats) {
+            context.stats.endTime = Date.now();
+            if (context.tokens) {
+                context.stats.processedTokens = context.tokens.length;
+            }
+        }
+        return context;
+    }
+}

package/dist/TCX/types.d.ts

@@ -0,0 +1,203 @@
+import { ExtensionsType, Token, TokenAST } from "../types.js";
+import { IProcessingContext } from "../core/base.js";
+/**
+ * TCX 文件类型
+ */
+export interface TCXFileType {
+    version?: string;
+    creator?: string;
+    xmlns?: string;
+    "xmlns:gte"?: string;
+    "xmlns:xsi"?: string;
+    "xsi:schemaLocation"?: string;
+    Folders?: FolderType;
+    Activities?: ActivityListType;
+    Workouts?: WorkoutListType;
+    Courses?: CourseListType;
+    Author?: AbstractSourceType;
+    Extensions?: any;
+    [key: string]: any | undefined;
+}
+export interface FolderType {
+    History?: HistoryType;
+    Workouts?: WorkoutListType;
+    Courses?: any;
+}
+export interface WorkoutListType {
+    Workout?: WorkoutType[];
+}
+export interface WorkoutType {
+    Name?: string;
+    Step?: AbstractStepType;
+    ScheduledOn?: string;
+    Notes?: string;
+    Creator?: AbstractSourceType;
+    Extensions?: ExtensionsType;
+}
+export interface AbstractSourceType {
+    Name?: string;
+}
+export interface AbstractStepType {
+    StepId?: string;
+}
+export interface CourseListType {
+    Course?: CourseType[];
+}
+export interface CourseType {
+    Name?: string;
+    Lap?: CourseLapType[];
+    Track?: TrackType[];
+    Notes?: string;
+    CoursePoint?: CoursePointType[];
+    Creator?: AbstractSourceType;
+    Extensions?: ExtensionsType;
+}
+export interface CoursePointType {
+    Name?: string;
+    Time?: number;
+    Position?: PositionType;
+    AltitudeMeters?: number;
+    PointType?: string;
+    Notes?: string;
+    Extensions?: ExtensionsType;
+}
+export interface CourseLapType {
+    TotalTimeSeconds?: number;
+    DistanceMeters?: number;
+    BeginPosition?: PositionType;
+    BeginAltitudeMeters?: number;
+    EndPosition?: PositionType;
+    EndAltitudeMeters?: number;
+    AverageHeartRateBpm?: number;
+    MaximumHeartRateBpm?: number;
+    Intensity?: IntensityType;
+    Cadence?: CadenceType;
+    Extensions?: ExtensionsType;
+}
+export interface HistoryType {
+    Running?: HistoryFolderType;
+    Biking?: HistoryFolderType;
+    Other?: HistoryFolderType;
+    MultiSport?: HistoryFolderType;
+    Extensions?: ExtensionsType;
+}
+export interface HistoryFolderType {
+    Folder?: HistoryFolderType;
+    ActivityRef?: ActivityRefType;
+    Week?: WeekType;
+    Notes?: string;
+    Extensions?: any;
+}
+export interface ActivityRefType {
+    Id: string;
+}
+export interface WeekType {
+    Notes?: string;
+    StartDay?: string;
+}
+export interface ActivityListType {
+    Activity?: ActivityType[];
+    MultiSportSession?: MultiSportSessionType[];
+}
+export interface ActivityType {
+    Sport?: "Other" | "Running" | "Biking";
+    Id: string;
+    Lap: ActivityLapType[];
+    Notes?: string;
+    Training?: any;
+    Creator?: any;
+    Extensions?: any;
+}
+export interface TrainingType {
+    QuickWorkoutResults?: QuickWorkoutType;
+    Plan?: PlanType;
+    VirtualPartner: boolean;
+}
+export interface QuickWorkoutType {
+    TotalTimeSeconds: number;
+    DistanceMeters: number;
+}
+export interface PlanType {
+    Name?: string;
+    Extensions?: any;
+    Type: "Workout" | "Course";
+    IntervalWorkout: boolean;
+}
+export interface ActivityLapType {
+    TotalTimeSeconds?: number;
+    DistanceMeters?: number;
+    MaximumSpeed?: number;
+    Calories?: number;
+    Heartratebpm?: number;
+    AverageHeartRateBpm?: number;
+    MaximumHeartRateBpm?: number;
+    Intensity?: IntensityType;
+    Cadence?: CadenceType;
+    TriggerMethod?: TriggerMethodType;
+    Track?: TrackType[];
+    Notes?: string;
+    Extensions?: any;
+}
+export type TriggerMethodType = "Manual" | "Distance" | "Location" | "Time" | "HeartRate";
+/**
+ * Active（高强度）
+ * Resting（低强度）
+ */
+export type IntensityType = "Active" | "Resting";
+export interface CadenceType {
+    Low: number;
+    High: number;
+}
+export interface HeartRateInBeatsPerMinuteType {
+    Value: number;
+}
+export interface MultiSportSessionType {
+    Id?: string;
+    FirstSport?: FirstSportType;
+    NextSport?: NextSportType[];
+    Notes?: string;
+}
+export interface FirstSportType {
+    Activity?: ActivityType;
+}
+/**
+ * Each sport contains an optional transition and a run.
+ */
+export interface NextSportType {
+    Transition?: ActivityLapType;
+    Activity?: ActivityType;
+}
+export interface TrackType {
+    Trackpoint?: TrackpointType[];
+}
+export interface TrackpointType {
+    Time?: string;
+    Position?: PositionType;
+    AltitudeMeters?: number;
+    DistanceMeters?: number;
+    HeartRateBpm?: number;
+    Cadence?: CadenceType;
+    SensorState?: "Present" | "Absent";
+    Extensions?: any;
+}
+export interface PositionType {
+    LatitudeDegrees?: string;
+    LongitudeDegrees?: string;
+}
+/**
+ * TCX 解码上下文
+ */
+export interface TCXContext extends IProcessingContext {
+    rawData?: Buffer;
+    xmlContent?: string;
+    tokens?: Token[];
+    ast?: TokenAST;
+    result?: TCXFileType;
+    performance: {
+        startTime: number;
+        tokenizeTime?: number;
+        astTime?: number;
+        convertTime?: number;
+        endTime?: number;
+    };
+}

package/dist/TCX/types.js

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

package/dist/core/base.d.ts

@@ -0,0 +1,119 @@
+import { ExtensionsType, Token, TokenAST } from "../types.js";
+/**
+ * 通用插件接口
+ */
+export interface IPlugin<TContext = any> {
+    /** 插件名称 */
+    name: string;
+    /** 插件版本 */
+    version?: string;
+    /** 插件描述 */
+    description?: string;
+    /** 依赖的其他插件 */
+    dependencies?: string[];
+    /** 支持的标签 */
+    supportedTags?: string[];
+    /** 插件初始化 */
+    initialize?(context: TContext): Promise<void> | void;
+    /** 插件销毁 */
+    destroy?(context: TContext): Promise<void> | void;
+    /** 插件验证 */
+    validate?(context: TContext): Promise<boolean> | boolean;
+}
+/**
+ * 通用转换器插件接口
+ */
+export interface IConverterPlugin<TContext = any> extends IPlugin<TContext> {
+    /** 转换方法 */
+    convert(ast: TokenAST, context: TContext): any | undefined;
+    /** 是否支持该标签 */
+    supports(tag: string): boolean;
+    /** 优先级（数字越小优先级越高） */
+    priority?: number;
+}
+/**
+ * 通用中间件插件接口
+ */
+export interface IMiddlewarePlugin<TContext = any, TResult = any> extends IPlugin<TContext> {
+    /** 优先级（数字越小优先级越高） */
+    priority?: number;
+    /** 在tokenize阶段执行 */
+    onTokenize?(tokens: Token[], context: TContext): Promise<Token[]> | Token[];
+    /** 在AST生成阶段执行 */
+    onAstGenerate?(ast: TokenAST, context: TContext): Promise<TokenAST> | TokenAST;
+    /** 在转换阶段执行 */
+    onConvert?(result: any, context: TContext): Promise<any> | any;
+    /** 在完成阶段执行 */
+    onComplete?(result: TResult, context: TContext): Promise<TResult> | TResult;
+    /** 错误处理 */
+    onError?(error: Error, context: TContext): Promise<void> | void;
+}
+/**
+ * 通用处理上下文
+ */
+export interface IProcessingContext {
+    /** 元数据存储 */
+    metadata: Map<string, any>;
+    /** 错误列表 */
+    errors: Error[];
+    /** 警告列表 */
+    warnings: string[];
+    /** 处理统计信息 */
+    stats: {
+        startTime: number;
+        endTime?: number;
+        processedTokens: number;
+        convertedElements: number;
+    };
+    /** 用户自定义数据 */
+    userData?: Record<string, any>;
+}
+/**
+ * 通用基础转换器抽象类
+ */
+export declare abstract class BaseConverter<TContext extends IProcessingContext = IProcessingContext> implements IConverterPlugin<TContext> {
+    abstract name: string;
+    abstract supportedTags: string[];
+    version: string;
+    priority: number;
+    abstract convert(ast: TokenAST, context: TContext): any | undefined;
+    supports(tag: string): boolean;
+    initialize(context: TContext): Promise<void>;
+    destroy(context: TContext): Promise<void>;
+    validate(context: TContext): Promise<boolean>;
+    protected parseFloat(value: string | number | undefined): number;
+    protected parseInt(value: string | number | undefined): number;
+    protected parseString(value: string | number | undefined): string;
+    protected parseBoolean(value: string | boolean | undefined): boolean;
+    protected parseDate(value: string | undefined): Date | undefined;
+    protected hasRequiredAttributes(ast: TokenAST, required: string[]): boolean;
+    protected extractAttributes<U extends Record<string, any>>(ast: TokenAST, target: U, mapping: Record<string, keyof U>): void;
+    protected processChildren<U extends Record<string, any>>(ast: TokenAST, target: U, processors: Record<string, (child: TokenAST, target: U) => void>): void;
+    protected getChildValue(ast: TokenAST, tag: string): string | undefined;
+    protected getChildByTag(ast: TokenAST, tag: string): TokenAST | undefined;
+    protected getChildrenByTag(ast: TokenAST, tag: string): TokenAST[];
+    /**
+     * 通用的 Extensions 处理方法
+     */
+    protected convertExtensions(extensionsAST: TokenAST): ExtensionsType;
+    /**
+     * 递归转换 Extensions 内容
+     */
+    protected convertExtensionContent(extension: TokenAST): any;
+}
+/**
+ * 通用基础中间件抽象类
+ */
+export declare abstract class BaseMiddleware<TContext extends IProcessingContext = IProcessingContext, TResult = any> implements IMiddlewarePlugin<TContext, TResult> {
+    abstract name: string;
+    version: string;
+    description: string;
+    initialize(context: TContext): Promise<void>;
+    destroy(context: TContext): Promise<void>;
+    validate(context: TContext): Promise<boolean>;
+    onTokenize(tokens: Token[], context: TContext): Promise<Token[]>;
+    onAstGenerate(ast: TokenAST, context: TContext): Promise<TokenAST>;
+    onConvert(result: any, context: TContext): Promise<any>;
+    onComplete(result: TResult, context: TContext): Promise<TResult>;
+    onError(error: Error, context: TContext): Promise<void>;
+}

package/dist/core/base.js

@@ -0,0 +1,138 @@
+// ============ 基础工具类 ============
+/**
+ * 通用基础转换器抽象类
+ */
+export class BaseConverter {
+    constructor() {
+        this.version = "1.0.0";
+        this.priority = 100;
+    }
+    supports(tag) {
+        return this.supportedTags.includes(tag);
+    }
+    async initialize(context) {
+        context.metadata.set(`plugin:${this.name}:initialized`, true);
+    }
+    async destroy(context) {
+        context.metadata.delete(`plugin:${this.name}:initialized`);
+    }
+    async validate(context) {
+        return true;
+    }
+    // ============ 通用工具方法 ============
+    parseFloat(value) {
+        if (typeof value === "number")
+            return value;
+        if (typeof value === "string")
+            return parseFloat(value) || 0;
+        return 0;
+    }
+    parseInt(value) {
+        if (typeof value === "number")
+            return Math.floor(value);
+        if (typeof value === "string")
+            return parseInt(value, 10) || 0;
+        return 0;
+    }
+    parseString(value) {
+        return String(value || "");
+    }
+    parseBoolean(value) {
+        if (typeof value === "boolean")
+            return value;
+        if (typeof value === "string")
+            return value.toLowerCase() === "true";
+        return false;
+    }
+    parseDate(value) {
+        if (!value)
+            return undefined;
+        const date = new Date(value);
+        return isNaN(date.getTime()) ? undefined : date;
+    }
+    hasRequiredAttributes(ast, required) {
+        return required.every((attr) => ast.attributes?.[attr]);
+    }
+    extractAttributes(ast, target, mapping) {
+        if (!ast.attributes)
+            return;
+        Object.entries(ast.attributes).forEach(([key, value]) => {
+            const targetKey = mapping[key];
+            if (targetKey && targetKey in target) {
+                target[targetKey] = String(value || "");
+            }
+        });
+    }
+    processChildren(ast, target, processors) {
+        ast.children?.forEach((child) => {
+            const fn = processors[child.tag];
+            if (fn)
+                fn(child, target);
+        });
+    }
+    getChildValue(ast, tag) {
+        const child = ast.children?.find((c) => c.tag === tag);
+        return child?.value ? String(child.value) : undefined;
+    }
+    getChildByTag(ast, tag) {
+        return ast.children?.find((c) => c.tag === tag);
+    }
+    getChildrenByTag(ast, tag) {
+        return ast.children?.filter((c) => c.tag === tag) || [];
+    }
+    // ============ 扩展处理工具 ============
+    /**
+     * 通用的 Extensions 处理方法
+     */
+    convertExtensions(extensionsAST) {
+        const extensions = {};
+        extensionsAST.children?.forEach((child) => {
+            extensions[child.tag] = this.convertExtensionContent(child);
+        });
+        return extensions;
+    }
+    /**
+     * 递归转换 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 BaseMiddleware {
+    constructor() {
+        this.version = "1.0.0";
+        this.description = "";
+    }
+    async initialize(context) { }
+    async destroy(context) { }
+    async validate(context) {
+        return true;
+    }
+    async onTokenize(tokens, context) {
+        return tokens;
+    }
+    async onAstGenerate(ast, context) {
+        return ast;
+    }
+    async onConvert(result, context) {
+        return result;
+    }
+    async onComplete(result, context) {
+        return result;
+    }
+    async onError(error, context) {
+        console.error(`中间件 ${this.name} 处理错误:`, error);
+    }
+}