trackswap 0.0.1

package/dist/GPX/decoder.js

@@ -0,0 +1,403 @@
+import { BoundsConverter, CopyrightConverter, EmailConverter, LinkConverter, MetadataConverter, PersonConverter, RteConverter, TrkConverter, TrksegConverter, WptConverter, } from "./converters.js";
+import { AstGenerateProcessor, CompleteProcessor, ConvertProcessor, TokenizeProcessor, PipelineStage, } from "./processor.js";
+// ============ 主解码器类 ============
+/**
+ * GPX解码器主类
+ */
+export class GPXDecoder {
+    constructor() {
+        this.converterPlugins = new Map();
+        this.registeredPlugins = new Set(); // 跟踪已注册的插件名
+        this.middlewarePlugins = [];
+        this.processors = []; // 固定的核心处理器
+        this.initialized = false;
+        this.defaultConvertersRegistered = false;
+        this.initializePipeline();
+    }
+    /**
+     * 初始化流水线 - 注册固定的核心处理器
+     */
+    initializePipeline() {
+        // 固定的核心处理器，不允许用户修改
+        this.processors = [
+            new TokenizeProcessor(),
+            new AstGenerateProcessor(),
+            new ConvertProcessor((tag) => this.getConverter(tag)),
+            new CompleteProcessor(),
+        ];
+        console.log("🔧 核心流水线处理器已初始化 (固定不可修改)");
+    }
+    /**
+     * 自动注册默认转换器 - 处理标准GPX标签
+     */
+    async registerDefaultConverters() {
+        if (this.defaultConvertersRegistered)
+            return;
+        const defaultConverters = [
+            new WptConverter(),
+            new RteConverter(),
+            new TrkConverter(),
+            new TrksegConverter(),
+            new LinkConverter(),
+            new MetadataConverter(),
+            new PersonConverter(),
+            new EmailConverter(),
+            new CopyrightConverter(),
+            new BoundsConverter(),
+        ];
+        for (const converter of defaultConverters) {
+            // 内部注册，不显示日志避免干扰
+            converter.supportedTags?.forEach((tag) => {
+                this.addConverterForTag(tag, converter);
+            });
+            this.registeredPlugins.add(converter.name);
+        }
+        this.defaultConvertersRegistered = true;
+        console.log("✅ 默认GPX转换器已自动注册 (wpt, rte, trk, metadata等)");
+    }
+    /**
+     * 为指定标签添加转换器，按优先级排序
+     */
+    addConverterForTag(tag, converter) {
+        if (!this.converterPlugins.has(tag)) {
+            this.converterPlugins.set(tag, []);
+        }
+        const converters = this.converterPlugins.get(tag);
+        converters.push(converter);
+        // 按优先级排序（数字越小优先级越高）
+        converters.sort((a, b) => (a.priority || 100) - (b.priority || 100));
+    }
+    /**
+     * 注册转换器插件
+     */
+    async registerConverter(plugin) {
+        // 检查插件是否已注册
+        if (this.registeredPlugins.has(plugin.name)) {
+            throw new Error(`转换器插件 ${plugin.name} 已存在`);
+        }
+        // 注册支持的标签（允许多个转换器处理同一标签）
+        plugin.supportedTags?.forEach((tag) => {
+            this.addConverterForTag(tag, plugin);
+        });
+        this.registeredPlugins.add(plugin.name);
+        // 显示优先级信息
+        const priorityInfo = plugin.priority !== undefined ? ` (优先级: ${plugin.priority})` : "";
+        console.log(`📦 已注册自定义转换器: ${plugin.name}${priorityInfo}, 支持标签: ${plugin.supportedTags?.join(", ")}`);
+        // 显示标签的转换器优先级顺序
+        plugin.supportedTags?.forEach((tag) => {
+            const converters = this.converterPlugins.get(tag) || [];
+            const converterNames = converters.map((c) => `${c.name}(${c.priority || 100})`);
+            console.log(`   📋 标签 "${tag}" 转换器优先级: ${converterNames.join(" > ")}`);
+        });
+    }
+    /**
+     * 注册中间件插件 - 真正的扩展点
+     */
+    async registerMiddleware(plugin) {
+        const existingIndex = this.middlewarePlugins.findIndex((p) => p.name === plugin.name);
+        if (existingIndex !== -1) {
+            this.middlewarePlugins[existingIndex] = plugin;
+            console.log(`🔄 已更新中间件: ${plugin.name}`);
+        }
+        else {
+            this.middlewarePlugins.push(plugin);
+            console.log(`🔌 已注册中间件: ${plugin.name}`);
+        }
+        // 显示中间件支持的钩子
+        const hooks = [];
+        if (plugin.onTokenize)
+            hooks.push("onTokenize");
+        if (plugin.onAstGenerate)
+            hooks.push("onAstGenerate");
+        if (plugin.onConvert)
+            hooks.push("onConvert");
+        if (plugin.onComplete)
+            hooks.push("onComplete");
+        if (plugin.onError)
+            hooks.push("onError");
+        if (hooks.length > 0) {
+            console.log(`   🎣 支持的钩子: ${hooks.join(", ")}`);
+        }
+    }
+    /**
+     * 获取转换器（返回优先级最高的）
+     */
+    getConverter(tag) {
+        const converters = this.converterPlugins.get(tag);
+        return converters && converters.length > 0 ? converters[0] : undefined;
+    }
+    /**
+     * 获取指定标签的所有转换器（按优先级排序）
+     */
+    getAllConverters(tag) {
+        return this.converterPlugins.get(tag) || [];
+    }
+    /**
+     * 移除转换器
+     */
+    unregisterConverter(pluginName) {
+        // 找到插件实例
+        let pluginToRemove;
+        for (const [tag, converters] of this.converterPlugins) {
+            const index = converters.findIndex((plugin) => plugin.name === pluginName);
+            if (index !== -1) {
+                pluginToRemove = converters[index];
+                converters.splice(index, 1);
+                // 如果该标签没有转换器了，删除整个条目
+                if (converters.length === 0) {
+                    this.converterPlugins.delete(tag);
+                }
+            }
+        }
+        if (!pluginToRemove) {
+            console.warn(`转换器插件 ${pluginName} 不存在`);
+            return;
+        }
+        this.registeredPlugins.delete(pluginName);
+        console.log(`🗑️ 已移除转换器: ${pluginName}`);
+    }
+    /**
+     * 移除中间件
+     */
+    unregisterMiddleware(name) {
+        const index = this.middlewarePlugins.findIndex((p) => p.name === name);
+        if (index !== -1) {
+            this.middlewarePlugins.splice(index, 1);
+            console.log(`🗑️ 已移除中间件: ${name}`);
+        }
+        else {
+            console.warn(`中间件 ${name} 不存在`);
+        }
+    }
+    /**
+     * 列出所有已注册的转换器标签
+     */
+    listConverters() {
+        return Array.from(this.converterPlugins.keys());
+    }
+    /**
+     * 列出所有已注册的转换器插件
+     */
+    listConverterPlugins() {
+        return Array.from(this.registeredPlugins);
+    }
+    /**
+     * 列出所有已注册的中间件
+     */
+    listMiddlewares() {
+        return this.middlewarePlugins.map((p) => p.name);
+    }
+    /**
+     * 列出核心处理器（只读）
+     */
+    listProcessors() {
+        return this.processors.map((p) => p.constructor.name);
+    }
+    /**
+     * 获取标签的转换器详情（包括优先级信息）
+     */
+    getConverterDetails(tag) {
+        const result = {};
+        if (tag) {
+            const converters = this.converterPlugins.get(tag);
+            if (converters) {
+                result[tag] = converters.map((c) => ({
+                    name: c.name,
+                    priority: c.priority || 100,
+                }));
+            }
+        }
+        else {
+            for (const [tagName, converters] of this.converterPlugins) {
+                result[tagName] = converters.map((c) => ({
+                    name: c.name,
+                    priority: c.priority || 100,
+                }));
+            }
+        }
+        return result;
+    }
+    /**
+     * 获取中间件详情（包括支持的钩子）
+     */
+    getMiddlewareDetails() {
+        return this.middlewarePlugins.map((plugin) => {
+            const hooks = [];
+            if (plugin.onTokenize)
+                hooks.push("onTokenize");
+            if (plugin.onAstGenerate)
+                hooks.push("onAstGenerate");
+            if (plugin.onConvert)
+                hooks.push("onConvert");
+            if (plugin.onComplete)
+                hooks.push("onComplete");
+            if (plugin.onError)
+                hooks.push("onError");
+            return {
+                name: plugin.name,
+                hooks,
+            };
+        });
+    }
+    /**
+     * 初始化解码器
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        // 首先注册默认转换器
+        await this.registerDefaultConverters();
+        const context = this.createContext();
+        // 初始化所有插件
+        const allPlugins = [
+            ...Array.from(this.converterPlugins.values()).flat(),
+            ...this.middlewarePlugins,
+        ];
+        for (const plugin of allPlugins) {
+            try {
+                await plugin.initialize?.(context);
+            }
+            catch (error) {
+                console.error(`插件 ${plugin.name} 初始化失败:`, error);
+            }
+        }
+        this.initialized = true;
+    }
+    /**
+     * 销毁解码器
+     */
+    async destroy() {
+        if (!this.initialized)
+            return;
+        const context = this.createContext();
+        // 销毁所有插件
+        const allPlugins = [
+            ...Array.from(this.converterPlugins.values()).flat(),
+            ...this.middlewarePlugins,
+        ];
+        for (const plugin of allPlugins) {
+            try {
+                await plugin.destroy?.(context);
+            }
+            catch (error) {
+                console.error(`插件 ${plugin.name} 销毁失败:`, error);
+            }
+        }
+        this.initialized = false;
+    }
+    /**
+     * 创建解码上下文
+     */
+    createContext() {
+        return {
+            metadata: new Map(),
+            errors: [],
+            performance: {
+                startTime: Date.now(),
+            },
+        };
+    }
+    /**
+     * 执行中间件钩子
+     */
+    async executeMiddlewareHook(hookName, data, context) {
+        let result = data;
+        for (const middleware of this.middlewarePlugins) {
+            const hook = middleware[hookName];
+            if (hook) {
+                try {
+                    result = (await hook.call(middleware, result, context)) || result;
+                }
+                catch (error) {
+                    context.errors.push(error);
+                    await middleware.onError?.(error, context);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * 主解析方法 - 固定的流水线 + 灵活的中间件
+     */
+    async parserByBuffer(buffer) {
+        await this.initialize();
+        let context = this.createContext();
+        context.rawData = buffer;
+        context.xmlContent = buffer.toString("utf-8");
+        // 在上下文中传递解码器实例引用
+        context.metadata.set("decoder", this);
+        try {
+            // 固定的流水线阶段顺序执行
+            for (const processor of this.processors) {
+                try {
+                    // 1. 执行核心处理器
+                    context = await processor.process(context);
+                    // 2. 根据阶段执行对应的中间件钩子
+                    switch (processor.stage) {
+                        case PipelineStage.TOKENIZE:
+                            if (context.tokens) {
+                                context.tokens = await this.executeMiddlewareHook("onTokenize", context.tokens, context);
+                            }
+                            break;
+                        case PipelineStage.AST_GENERATE:
+                            if (context.ast) {
+                                context.ast = await this.executeMiddlewareHook("onAstGenerate", context.ast, context);
+                            }
+                            break;
+                        case PipelineStage.CONVERT:
+                            if (context.result) {
+                                context.result = await this.executeMiddlewareHook("onConvert", context.result, context);
+                            }
+                            break;
+                        case PipelineStage.COMPLETE:
+                            if (context.result) {
+                                context.result = await this.executeMiddlewareHook("onComplete", context.result, context);
+                            }
+                            break;
+                    }
+                }
+                catch (error) {
+                    context.errors.push(error);
+                    // 执行错误处理中间件
+                    for (const middleware of this.middlewarePlugins) {
+                        await middleware.onError?.(error, context);
+                    }
+                    console.error(`流水线阶段 ${processor.stage} 处理失败:`, error);
+                }
+            }
+            return context.result;
+        }
+        catch (error) {
+            console.error("GPX解析失败:", error);
+            throw error;
+        }
+    }
+    /**
+     * 转换Extensions（向后兼容）
+     */
+    convertExtensions(extensionsAST) {
+        const extensions = {};
+        const { attributes, tag, value } = extensionsAST;
+        // 处理属性
+        if (attributes) {
+            Object.entries(attributes).forEach(([key, value]) => {
+                extensions[key] = value;
+            });
+        }
+        // 如果有子节点，直接处理子节点，不再包装外层标签
+        if (extensionsAST?.children?.length) {
+            extensionsAST.children?.forEach((child) => {
+                extensions[child.tag] =
+                    this.convertExtensions(child);
+            });
+        }
+        else if (value !== undefined) {
+            // 如果没有子节点但有值，直接返回值
+            return value;
+        }
+        return extensions;
+    }
+}
+export default {
+    GPXDecoder,
+};

package/dist/GPX/encoder.d.ts

@@ -0,0 +1,150 @@
+import { GPX11Type } from "./types.js";
+/**
+ * GPX 编码器 - 将 GPX11Type 数据编码为 GPX XML 格式
+ */
+export declare class GPXEncoder {
+    private compact;
+    /**
+     * 构造函数
+     * @param options 编码器选项
+     */
+    constructor(options?: {
+        compact?: boolean;
+    });
+    /**
+     * 编码 GPX 数据为 Buffer
+     */
+    encode(gpxData: GPX11Type): Promise<Buffer>;
+    /**
+     * 编码 GPX 数据为 XML 字符串
+     */
+    encodeToString(gpxData: GPX11Type): string;
+    /**
+     * 构建完整的 GPX XML
+     */
+    private buildGPXXML;
+    /**
+     * 压缩XML字符串，去掉多余的换行和空格
+     */
+    private compressXML;
+    /**
+     * 构建 XML 头部
+     */
+    private buildXMLHeader;
+    /**
+     * 构建 GPX 内容
+     */
+    private buildGPXContent;
+    /**
+     * 构建 metadata 元素
+     */
+    private buildMetadata;
+    /**
+     * 构建 author 元素
+     */
+    private buildAuthor;
+    /**
+     * 构建 copyright 元素
+     */
+    private buildCopyright;
+    /**
+     * 构建 bounds 元素
+     */
+    private buildBounds;
+    /**
+     * 构建航路点元素
+     */
+    private buildWaypoint;
+    /**
+     * 添加标准航路点元素
+     */
+    private addStandardWaypointElements;
+    /**
+     * 构建 rte 元素
+     */
+    private buildRoute;
+    /**
+     * 构建轨迹元素
+     */
+    private buildTrack;
+    /**
+     * 构建轨迹段元素
+     */
+    private buildTrackSegment;
+    /**
+     * 添加路线和轨迹的公共元素
+     */
+    private addRouteTrackCommonElements;
+    /**
+     * 处理点的扩展属性
+     */
+    private processPointExtensions;
+    /**
+     * 构建 TrackPoint 扩展
+     */
+    private buildTrackPointExtension;
+    /**
+     * 构建 Power 扩展
+     */
+    private buildPowerExtension;
+    /**
+     * 构建 GPX 扩展
+     */
+    private buildGpxExtensions;
+    /**
+     * 构建扩展元素
+     */
+    private buildExtensions;
+    /**
+     * 递归构建扩展内容
+     */
+    private buildExtensionContent;
+    /**
+     * 构建 link 元素
+     */
+    private buildLink;
+    /**
+     * 添加多个 link 元素
+     */
+    private addLinks;
+    /**
+     * 构建时间元素
+     */
+    private buildTimeElement;
+    /**
+     * 添加可选元素
+     */
+    private addOptionalElement;
+    /**
+     * 验证坐标有效性
+     */
+    private isValidCoordinate;
+    /**
+     * 格式化坐标
+     */
+    private formatCoordinate;
+    /**
+     * 格式化高程
+     */
+    private formatElevation;
+    /**
+     * 数字四舍五入
+     */
+    private roundTo;
+    /**
+     * XML 转义
+     */
+    private escapeXML;
+    /**
+     * XML 属性值转义（专门用于属性值的安全转义）
+     */
+    private escapeXMLAttribute;
+    /**
+     * 深度拷贝
+     */
+    private deepClone;
+    /**
+     * @deprecated 使用 encode() 替代
+     */
+    encoder(node: GPX11Type): Promise<Buffer>;
+}