trackswap 0.0.2 → 0.0.4

package/dist/TCX/processor.js

@@ -1,197 +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 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.js

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

package/dist/TrackSwap.js

@@ -1,84 +0,0 @@
-import { GPXDecoder, GPXEncoder } from "./GPX/index.js";
-/**
- * GPX轨迹交换处理类
- * 提供GPX文件的解析和编码功能
- */
-export class TrackSwap {
-    constructor() {
-        this.decoder = new GPXDecoder();
-        this.encoder = new GPXEncoder();
-    }
-    // ==================== 解析功能 ====================
-    /**
-     * 解析GPX文件Buffer为GPX对象
-     */
-    async parseGPX(buffer) {
-        try {
-            return await this.decoder.parserByBuffer(buffer);
-        }
-        catch (error) {
-            console.error("GPX解析失败:", error);
-            throw new Error(`GPX解析失败: ${error.message}`);
-        }
-    }
-    /**
-     * 解析GPX文件字符串为GPX对象
-     */
-    async parseGPXString(xmlString) {
-        const buffer = Buffer.from(xmlString, "utf-8");
-        return this.parseGPX(buffer);
-    }
-    // ==================== 编码功能 ====================
-    /**
-     * 编码GPX对象为Buffer
-     */
-    async encodeGPX(gpxData) {
-        try {
-            return await this.encoder.encode(gpxData);
-        }
-        catch (error) {
-            console.error("GPX编码失败:", error);
-            throw new Error(`GPX编码失败: ${error.message}`);
-        }
-    }
-    /**
-     * 编码GPX对象为XML字符串
-     */
-    encodeGPXString(gpxData) {
-        try {
-            return this.encoder.encodeToString(gpxData);
-        }
-        catch (error) {
-            console.error("GPX编码失败:", error);
-            throw new Error(`GPX编码失败: ${error.message}`);
-        }
-    }
-    // ==================== 实例管理 ====================
-    /**
-     * 获取解码器实例
-     */
-    getDecoder() {
-        return this.decoder;
-    }
-    /**
-     * 获取编码器实例
-     */
-    getEncoder() {
-        return this.encoder;
-    }
-    /**
-     * 销毁实例，清理资源
-     */
-    async destroy() {
-        await this.decoder.destroy();
-    }
-    // ==================== 向后兼容 ====================
-    /**
-     * @deprecated 使用 encodeGPX() 替代
-     */
-    async encoderGPX(gpx) {
-        return this.encodeGPX(gpx);
-    }
-}
-// 默认导出
-export default { TrackSwap };

package/dist/core/base.js

@@ -1,138 +0,0 @@
-// ============ 基础工具类 ============
-/**
- * 通用基础转换器抽象类
- */
-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);
-    }
-}

package/dist/core/decoder.d.ts

@@ -1,66 +0,0 @@
-import { IPlugin, IProcessingContext } from "./base.js";
-import { Processor } from "./processor.js";
-/**
- * 通用解码器基类
- */
-export declare abstract class BaseDecoder<TContext extends IProcessingContext = IProcessingContext, TResult = any> {
-    protected processor: Processor<TContext, TResult>;
-    protected initialized: boolean;
-    constructor();
-    /**
-     * 抽象方法：初始化默认转换器
-     */
-    protected abstract initializeDefaultConverters(): void;
-    /**
-     * 抽象方法：创建处理上下文
-     */
-    protected abstract createContext(options: {
-        skipValidation?: boolean;
-        enableStats?: boolean;
-        userData?: Record<string, any>;
-    }): TContext;
-    /**
-     * 解析 Buffer 数据
-     */
-    parseByBuffer(buffer: Buffer, options?: {
-        skipValidation?: boolean;
-        enableStats?: boolean;
-        userData?: Record<string, any>;
-    }): Promise<TResult>;
-    /**
-     * 解析 XML 字符串
-     */
-    parseByString(xmlContent: string, options?: {
-        skipValidation?: boolean;
-        enableStats?: boolean;
-        userData?: Record<string, any>;
-    }): Promise<TResult>;
-    /**
-     * 注册自定义插件
-     */
-    registerPlugin(plugin: IPlugin<TContext>): void;
-    /**
-     * 批量注册插件
-     */
-    registerPlugins(plugins: IPlugin<TContext>[]): void;
-    /**
-     * 移除插件
-     */
-    unregisterPlugin(name: string): boolean;
-    /**
-     * 获取已注册的插件列表
-     */
-    getRegisteredPlugins(): IPlugin<TContext>[];
-    /**
-     * 清空所有插件（保留默认转换器）
-     */
-    reset(): void;
-    /**
-     * 获取处理器实例（用于高级自定义）
-     */
-    getProcessor(): Processor<TContext, TResult>;
-    /**
-     * 获取转换器
-     */
-    getConverter(tag: string): import("./base.js").IConverterPlugin<TContext> | undefined;
-}

package/dist/core/decoder.js

@@ -1,90 +0,0 @@
-import { Processor } from "./processor.js";
-import { XMLUtils } from "./xml-utils.js";
-/**
- * 通用解码器基类
- */
-export class BaseDecoder {
-    constructor() {
-        this.initialized = false;
-        this.processor = new Processor();
-    }
-    /**
-     * 解析 Buffer 数据
-     */
-    async parseByBuffer(buffer, options = {}) {
-        const xmlContent = buffer.toString("utf-8");
-        return this.parseByString(xmlContent, options);
-    }
-    /**
-     * 解析 XML 字符串
-     */
-    async parseByString(xmlContent, options = {}) {
-        try {
-            // 确保转换器已初始化
-            if (!this.initialized) {
-                this.initializeDefaultConverters();
-            }
-            // 验证 XML 格式
-            if (!options.skipValidation) {
-                const validation = XMLUtils.validateXML(xmlContent);
-                if (!validation.isValid) {
-                    throw new Error(`XML 格式错误: ${validation.error}`);
-                }
-            }
-            // 1. Tokenize XML
-            const tokens = XMLUtils.tokenizeXML(xmlContent);
-            // 2. 创建上下文
-            const context = this.createContext(options);
-            // 3. 使用处理器处理
-            const result = await this.processor.process(tokens, context, options);
-            return result;
-        }
-        catch (error) {
-            throw new Error(`解析失败: ${error.message}`);
-        }
-    }
-    /**
-     * 注册自定义插件
-     */
-    registerPlugin(plugin) {
-        this.processor.registerPlugin(plugin);
-    }
-    /**
-     * 批量注册插件
-     */
-    registerPlugins(plugins) {
-        this.processor.registerPlugins(plugins);
-    }
-    /**
-     * 移除插件
-     */
-    unregisterPlugin(name) {
-        return this.processor.unregisterPlugin(name);
-    }
-    /**
-     * 获取已注册的插件列表
-     */
-    getRegisteredPlugins() {
-        return this.processor.getRegisteredPlugins();
-    }
-    /**
-     * 清空所有插件（保留默认转换器）
-     */
-    reset() {
-        this.processor.clear();
-        this.initialized = false;
-        this.initializeDefaultConverters();
-    }
-    /**
-     * 获取处理器实例（用于高级自定义）
-     */
-    getProcessor() {
-        return this.processor;
-    }
-    /**
-     * 获取转换器
-     */
-    getConverter(tag) {
-        return this.processor.getConverter(tag);
-    }
-}

package/dist/core/index.js

@@ -1,4 +0,0 @@
-// ============ 基础架构 ============
-export { BaseConverter, BaseMiddleware, } from "./base.js";
-// ============ XML 工具 ============
-export { XMLUtils } from "./xml-utils.js";

package/dist/core/processor.d.ts

@@ -1,69 +0,0 @@
-import { Token, TokenAST } from "../types.js";
-import { IPlugin, IConverterPlugin, IProcessingContext } from "./base.js";
-/**
- * 通用处理器 - 负责管理插件和处理流程
- */
-export declare class Processor<TContext extends IProcessingContext = IProcessingContext, TResult = any> {
-    private converters;
-    private middlewares;
-    private plugins;
-    /**
-     * 注册插件
-     */
-    registerPlugin(plugin: IPlugin<TContext>): void;
-    /**
-     * 批量注册插件
-     */
-    registerPlugins(plugins: IPlugin<TContext>[]): void;
-    /**
-     * 获取转换器
-     */
-    getConverter(tag: string): IConverterPlugin<TContext> | undefined;
-    /**
-     * 移除插件
-     */
-    unregisterPlugin(name: string): boolean;
-    /**
-     * 获取已注册的插件列表
-     */
-    getRegisteredPlugins(): IPlugin<TContext>[];
-    /**
-     * 清空所有插件
-     */
-    clear(): void;
-    /**
-     * 处理数据 - 四阶段处理流程
-     */
-    process(tokens: Token[], context: TContext, options?: {
-        skipValidation?: boolean;
-        enableStats?: boolean;
-    }): Promise<TResult>;
-    /**
-     * 生成 AST
-     */
-    generateAST(tokens: Token[]): TokenAST;
-    /**
-     * 转换 AST
-     */
-    convertAST(ast: TokenAST, context: TContext): any;
-    /**
-     * 通用转换逻辑
-     */
-    private convertGeneric;
-    /**
-     * 初始化插件
-     */
-    private initializePlugins;
-    /**
-     * 销毁插件
-     */
-    private destroyPlugins;
-    /**
-     * 检查是否为转换器插件
-     */
-    private isConverterPlugin;
-    /**
-     * 检查是否为中间件插件
-     */
-    private isMiddlewarePlugin;
-}