trackswap 0.0.1 → 0.0.3

package/dist/GPX/converters.js

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