trackswap 0.0.1

package/dist/GPX/converters.js

@@ -0,0 +1,444 @@
+import { BaseConverter, BaseMiddleware } from "./base.js";
+// ============ 核心转换器 ============
+/**
+ * WPT转换器
+ */
+export class WptConverter extends BaseConverter {
+    constructor() {
+        super(...arguments);
+        this.name = "wpt-converter";
+        this.supportedTags = ["wpt", "trkpt", "rtept"];
+        this.version = "1.0.0";
+    }
+    convert(ast, context) {
+        if (!this.hasRequiredAttributes(ast, ["lat", "lon"])) {
+            console.error(`${this.name}: 缺少必需的lat或lon属性`);
+            return undefined;
+        }
+        const wpt = {
+            lat: this.parseFloat(ast.attributes["lat"]),
+            lon: this.parseFloat(ast.attributes["lon"]),
+        };
+        // 处理其他属性
+        this.extractAttributes(ast, wpt, {
+            lat: "lat",
+            lon: "lon",
+        });
+        // 处理子节点
+        this.processChildren(ast, wpt, {
+            ele: (child, target) => (target.ele = this.parseFloat(child.value)),
+            time: (child, target) => (target.time = new Date(this.parseString(child.value))),
+            speed: (child, target) => (target.speed = this.parseFloat(child.value)),
+            course: (child, target) => (target.course = this.parseFloat(child.value)),
+            name: (child, target) => (target.name = this.parseString(child.value)),
+            cmt: (child, target) => (target.cmt = this.parseString(child.value)),
+            desc: (child, target) => (target.desc = this.parseString(child.value)),
+            src: (child, target) => (target.src = this.parseString(child.value)),
+            sym: (child, target) => (target.sym = this.parseString(child.value)),
+            type: (child, target) => (target.type = this.parseString(child.value)),
+            fix: (child, target) => (target.fix = this.parseString(child.value)),
+            sat: (child, target) => (target.sat = this.parseString(child.value)),
+            hdop: (child, target) => (target.hdop = this.parseFloat(child.value)),
+            vdop: (child, target) => (target.vdop = this.parseFloat(child.value)),
+            pdop: (child, target) => (target.pdop = this.parseFloat(child.value)),
+            ageofdgpsdata: (child, target) => (target.ageofdgpsdata = this.parseFloat(child.value)),
+            geoidheight: (child, target) => (target.geoidheight = this.parseFloat(child.value)),
+            magvar: (child, target) => (target.magvar = this.parseFloat(child.value)),
+            dgpsid: (child, target) => (target.dgpsid = this.parseFloat(child.value)),
+            extensions: (child, target) => {
+                // 查找extensions转换器
+                const decoder = context.metadata.get("decoder");
+                if (decoder) {
+                    target.extensions = decoder.convertExtensions(child);
+                }
+            },
+            link: (child, target) => {
+                if (!target.link)
+                    target.link = [];
+                const decoder = context.metadata.get("decoder");
+                const link = decoder?.getConverter("link")?.convert(child, context);
+                if (link && target.link)
+                    target.link.push(link);
+            },
+        });
+        return wpt;
+    }
+}
+/**
+ * Route转换器
+ */
+export class RteConverter extends BaseConverter {
+    constructor() {
+        super(...arguments);
+        this.name = "rte-converter";
+        this.supportedTags = ["rte"];
+    }
+    convert(ast, context) {
+        const rte = { rtept: [] };
+        this.processChildren(ast, rte, {
+            name: (child, target) => (target.name = this.parseString(child.value)),
+            cmt: (child, target) => (target.cmt = this.parseString(child.value)),
+            desc: (child, target) => (target.desc = this.parseString(child.value)),
+            src: (child, target) => (target.src = this.parseString(child.value)),
+            number: (child, target) => (target.number = this.parseFloat(child.value)),
+            type: (child, target) => (target.type = this.parseString(child.value)),
+            rtept: (child, target) => {
+                const decoder = context.metadata.get("decoder");
+                const wpt = decoder?.getConverter("wpt")?.convert(child, context);
+                if (wpt && target.rtept) {
+                    target.rtept.push(wpt);
+                }
+            },
+            extensions: (child, target) => {
+                const decoder = context.metadata.get("decoder");
+                if (decoder) {
+                    target.extensions = decoder.convertExtensions(child);
+                }
+            },
+            link: (child, target) => {
+                if (!target.link)
+                    target.link = [];
+                const decoder = context.metadata.get("decoder");
+                child.children?.forEach((linkChild) => {
+                    const link = decoder
+                        ?.getConverter("link")
+                        ?.convert(linkChild, context);
+                    if (link && target.link)
+                        target.link.push(link);
+                });
+            },
+        });
+        return rte;
+    }
+}
+/**
+ * Track转换器
+ */
+export class TrkConverter extends BaseConverter {
+    constructor() {
+        super(...arguments);
+        this.name = "trk-converter";
+        this.supportedTags = ["trk"];
+    }
+    convert(ast, context) {
+        const trk = { trkseg: [] };
+        this.processChildren(ast, trk, {
+            name: (child, target) => (target.name = this.parseString(child.value)),
+            cmt: (child, target) => (target.cmt = this.parseString(child.value)),
+            desc: (child, target) => (target.desc = this.parseString(child.value)),
+            src: (child, target) => (target.src = this.parseString(child.value)),
+            number: (child, target) => (target.number = this.parseFloat(child.value)),
+            type: (child, target) => (target.type = this.parseString(child.value)),
+            trkseg: (child, target) => {
+                const decoder = context.metadata.get("decoder");
+                const trkseg = decoder?.getConverter("trkseg")?.convert(child, context);
+                if (trkseg && target.trkseg) {
+                    target.trkseg.push(trkseg);
+                }
+            },
+            extensions: (child, target) => {
+                const decoder = context.metadata.get("decoder");
+                if (decoder) {
+                    target.extensions = decoder.convertExtensions(child);
+                }
+            },
+            link: (child, target) => {
+                if (!target.link)
+                    target.link = [];
+                const decoder = context.metadata.get("decoder");
+                child.children?.forEach((linkChild) => {
+                    const link = decoder
+                        ?.getConverter("link")
+                        ?.convert(linkChild, context);
+                    if (link && target.link)
+                        target.link.push(link);
+                });
+            },
+        });
+        return trk;
+    }
+}
+/**
+ * Track Segment转换器
+ */
+export class TrksegConverter extends BaseConverter {
+    constructor() {
+        super(...arguments);
+        this.name = "trkseg-converter";
+        this.supportedTags = ["trkseg"];
+    }
+    convert(ast, context) {
+        const trkseg = { trkpt: [] };
+        this.processChildren(ast, trkseg, {
+            trkpt: (child, target) => {
+                const decoder = context.metadata.get("decoder");
+                const wpt = decoder?.getConverter("wpt")?.convert(child, context);
+                if (wpt && target.trkpt) {
+                    target.trkpt.push(wpt);
+                }
+            },
+            extensions: (child, target) => {
+                const decoder = context.metadata.get("decoder");
+                if (decoder) {
+                    target.extensions = decoder.convertExtensions(child);
+                }
+            },
+        });
+        return trkseg;
+    }
+}
+/**
+ * Link转换器
+ */
+export class LinkConverter extends BaseConverter {
+    constructor() {
+        super(...arguments);
+        this.name = "link-converter";
+        this.supportedTags = ["link"];
+    }
+    convert(ast, context) {
+        const link = {};
+        if (ast.attributes?.href) {
+            link.href = ast.attributes.href;
+        }
+        this.processChildren(ast, link, {
+            text: (child, target) => (target.text = this.parseString(child.value)),
+            type: (child, target) => (target.type = this.parseString(child.value)),
+        });
+        return link;
+    }
+}
+/**
+ * Metadata转换器
+ */
+export class MetadataConverter extends BaseConverter {
+    constructor() {
+        super(...arguments);
+        this.name = "metadata-converter";
+        this.supportedTags = ["metadata"];
+    }
+    convert(ast, context) {
+        const metadata = {};
+        this.processChildren(ast, metadata, {
+            name: (child, target) => (target.name = this.parseString(child.value)),
+            desc: (child, target) => (target.desc = this.parseString(child.value)),
+            keywords: (child, target) => (target.keywords = this.parseString(child.value)),
+            time: (child, target) => (target.time = new Date(this.parseString(child.value))),
+            author: (child, target) => {
+                const decoder = context.metadata.get("decoder");
+                target.author = decoder
+                    ?.getConverter("author")
+                    ?.convert(child, context);
+            },
+            copyright: (child, target) => {
+                const decoder = context.metadata.get("decoder");
+                target.copyright = decoder
+                    ?.getConverter("copyright")
+                    ?.convert(child, context);
+            },
+            bounds: (child, target) => {
+                const decoder = context.metadata.get("decoder");
+                target.bounds = decoder
+                    ?.getConverter("bounds")
+                    ?.convert(child, context);
+            },
+            extensions: (child, target) => {
+                const decoder = context.metadata.get("decoder");
+                if (decoder) {
+                    target.extensions = decoder.convertExtensions(child);
+                }
+            },
+            link: (child, target) => {
+                if (!target.link)
+                    target.link = [];
+                const decoder = context.metadata.get("decoder");
+                const link = decoder?.getConverter("link")?.convert(child, context);
+                if (link && target.link)
+                    target.link.push(link);
+            },
+        });
+        return metadata;
+    }
+}
+/**
+ * Person转换器
+ */
+export class PersonConverter extends BaseConverter {
+    constructor() {
+        super(...arguments);
+        this.name = "person-converter";
+        this.supportedTags = ["author"];
+    }
+    convert(ast, context) {
+        const person = {};
+        // 如果author标签直接包含文本值（如 <author>Matschi1000</author>）
+        if (ast.value && !ast.children?.length) {
+            person.name = this.parseString(ast.value);
+            return person;
+        }
+        // 处理包含子元素的情况（如 <author><name>...</name><email>...</email></author>）
+        this.processChildren(ast, person, {
+            name: (child, target) => (target.name = this.parseString(child.value)),
+            email: (child, target) => {
+                const decoder = context.metadata.get("decoder");
+                target.email = decoder?.getConverter("email")?.convert(child, context);
+            },
+            link: (child, target) => {
+                const decoder = context.metadata.get("decoder");
+                target.link = decoder?.getConverter("link")?.convert(child, context);
+            },
+        });
+        return person;
+    }
+}
+/**
+ * Email转换器
+ */
+export class EmailConverter extends BaseConverter {
+    constructor() {
+        super(...arguments);
+        this.name = "email-converter";
+        this.supportedTags = ["email"];
+    }
+    convert(ast, context) {
+        const email = {};
+        this.processChildren(ast, email, {
+            id: (child, target) => (target.id = this.parseString(child.value)),
+            domain: (child, target) => (target.domain = this.parseString(child.value)),
+        });
+        return email;
+    }
+}
+/**
+ * Copyright转换器
+ */
+export class CopyrightConverter extends BaseConverter {
+    constructor() {
+        super(...arguments);
+        this.name = "copyright-converter";
+        this.supportedTags = ["copyright"];
+    }
+    convert(ast, context) {
+        const copyright = {};
+        if (ast.attributes?.author) {
+            copyright.author = ast.attributes.author;
+        }
+        this.processChildren(ast, copyright, {
+            year: (child, target) => (target.year = this.parseString(child.value)),
+            license: (child, target) => (target.license = this.parseString(child.value)),
+        });
+        return copyright;
+    }
+}
+/**
+ * Bounds转换器
+ */
+export class BoundsConverter extends BaseConverter {
+    constructor() {
+        super(...arguments);
+        this.name = "bounds-converter";
+        this.supportedTags = ["bounds"];
+    }
+    convert(ast, context) {
+        const bounds = {};
+        this.extractAttributes(ast, bounds, {
+            minlat: "minlat",
+            minlon: "minlon",
+            maxlat: "maxlat",
+            maxlon: "maxlon",
+        });
+        return bounds;
+    }
+}
+// ============ 示例中间件 ============
+/**
+ * 性能监控中间件
+ */
+export class PerformanceMiddleware extends BaseMiddleware {
+    constructor() {
+        super(...arguments);
+        this.name = "performance-middleware";
+        this.description = "监控解析性能";
+    }
+    async onTokenize(tokens, context) {
+        console.log(`Token化完成，生成了 ${tokens.length} 个token`);
+        return tokens;
+    }
+    async onAstGenerate(ast, context) {
+        const nodeCount = this.countNodes(ast);
+        console.log(`AST生成完成，包含 ${nodeCount} 个节点`);
+        return ast;
+    }
+    async onComplete(result, context) {
+        const performance = context.metadata.get("performance");
+        console.log("解析性能统计:", performance);
+        return result;
+    }
+    countNodes(ast) {
+        let count = 1;
+        if (ast.children) {
+            for (const child of ast.children) {
+                count += this.countNodes(child);
+            }
+        }
+        return count;
+    }
+}
+/**
+ * 验证中间件
+ */
+export class ValidationMiddleware extends BaseMiddleware {
+    constructor() {
+        super(...arguments);
+        this.name = "validation-middleware";
+        this.description = "验证GPX数据的完整性";
+    }
+    async onComplete(result, context) {
+        const errors = this.validateGPX(result);
+        if (errors.length > 0) {
+            console.warn("GPX验证发现问题:", errors);
+            context.metadata.set("validation-errors", errors);
+        }
+        else {
+            console.log("GPX验证通过");
+        }
+        return result;
+    }
+    validateGPX(gpx) {
+        const errors = [];
+        if (!gpx.version) {
+            errors.push("缺少GPX版本信息");
+        }
+        if (!gpx.creator) {
+            errors.push("缺少GPX创建者信息");
+        }
+        // 验证轨迹点
+        if (gpx.trk) {
+            for (const track of gpx.trk) {
+                if (track.trkseg) {
+                    for (const segment of track.trkseg) {
+                        if (segment.trkpt) {
+                            for (const point of segment.trkpt) {
+                                if (typeof point.lat !== "number" ||
+                                    typeof point.lon !== "number") {
+                                    errors.push("轨迹点坐标无效");
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return errors;
+    }
+}
+// ============ 默认转换器注册函数 ============
+/**
+ * 注册所有默认中间件
+ */
+export async function registerDefaultMiddlewares(decoder) {
+    const middlewares = [new PerformanceMiddleware(), new ValidationMiddleware()];
+    for (const middleware of middlewares) {
+        await decoder.registerMiddleware(middleware);
+    }
+}

package/dist/GPX/decoder.d.ts

@@ -0,0 +1,109 @@
+import { ExtensionsType, TokenAST } from "../types.js";
+import { IConverterPlugin, IMiddlewarePlugin } from "./base.js";
+import { GPX11Type } from "./types.js";
+/**
+ * GPX解码器主类
+ */
+export declare class GPXDecoder {
+    private converterPlugins;
+    private registeredPlugins;
+    private middlewarePlugins;
+    private processors;
+    private initialized;
+    private defaultConvertersRegistered;
+    constructor();
+    /**
+     * 初始化流水线 - 注册固定的核心处理器
+     */
+    private initializePipeline;
+    /**
+     * 自动注册默认转换器 - 处理标准GPX标签
+     */
+    private registerDefaultConverters;
+    /**
+     * 为指定标签添加转换器，按优先级排序
+     */
+    private addConverterForTag;
+    /**
+     * 注册转换器插件
+     */
+    registerConverter(plugin: IConverterPlugin): Promise<void>;
+    /**
+     * 注册中间件插件 - 真正的扩展点
+     */
+    registerMiddleware(plugin: IMiddlewarePlugin): Promise<void>;
+    /**
+     * 获取转换器（返回优先级最高的）
+     */
+    getConverter(tag: string): IConverterPlugin | undefined;
+    /**
+     * 获取指定标签的所有转换器（按优先级排序）
+     */
+    getAllConverters(tag: string): IConverterPlugin[];
+    /**
+     * 移除转换器
+     */
+    unregisterConverter(pluginName: string): void;
+    /**
+     * 移除中间件
+     */
+    unregisterMiddleware(name: string): void;
+    /**
+     * 列出所有已注册的转换器标签
+     */
+    listConverters(): string[];
+    /**
+     * 列出所有已注册的转换器插件
+     */
+    listConverterPlugins(): string[];
+    /**
+     * 列出所有已注册的中间件
+     */
+    listMiddlewares(): string[];
+    /**
+     * 列出核心处理器（只读）
+     */
+    listProcessors(): string[];
+    /**
+     * 获取标签的转换器详情（包括优先级信息）
+     */
+    getConverterDetails(tag?: string): Record<string, Array<{
+        name: string;
+        priority: number;
+    }>>;
+    /**
+     * 获取中间件详情（包括支持的钩子）
+     */
+    getMiddlewareDetails(): Array<{
+        name: string;
+        hooks: string[];
+    }>;
+    /**
+     * 初始化解码器
+     */
+    initialize(): Promise<void>;
+    /**
+     * 销毁解码器
+     */
+    destroy(): Promise<void>;
+    /**
+     * 创建解码上下文
+     */
+    private createContext;
+    /**
+     * 执行中间件钩子
+     */
+    private executeMiddlewareHook;
+    /**
+     * 主解析方法 - 固定的流水线 + 灵活的中间件
+     */
+    parserByBuffer(buffer: Buffer): Promise<GPX11Type | undefined>;
+    /**
+     * 转换Extensions（向后兼容）
+     */
+    convertExtensions(extensionsAST: TokenAST): ExtensionsType;
+}
+declare const _default: {
+    GPXDecoder: typeof GPXDecoder;
+};
+export default _default;