trackswap 0.0.1 → 0.0.2

package/dist/core/decoder.d.ts

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,90 @@
+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.d.ts

@@ -0,0 +1,2 @@
+export { IPlugin, IConverterPlugin, IMiddlewarePlugin, IProcessingContext, BaseConverter, BaseMiddleware, } from "./base.js";
+export { XMLUtils } from "./xml-utils.js";

package/dist/core/index.js

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

package/dist/core/processor.d.ts

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

package/dist/core/processor.js

@@ -0,0 +1,265 @@
+/**
+ * 通用处理器 - 负责管理插件和处理流程
+ */
+export class Processor {
+    constructor() {
+        this.converters = new Map();
+        this.middlewares = [];
+        this.plugins = new Map();
+    }
+    /**
+     * 注册插件
+     */
+    registerPlugin(plugin) {
+        if (this.plugins.has(plugin.name)) {
+            throw new Error(`插件 ${plugin.name} 已存在`);
+        }
+        this.plugins.set(plugin.name, plugin);
+        // 根据插件类型注册到相应的集合
+        if (this.isConverterPlugin(plugin)) {
+            plugin.supportedTags?.forEach((tag) => {
+                this.converters.set(tag, plugin);
+            });
+        }
+        if (this.isMiddlewarePlugin(plugin)) {
+            this.middlewares.push(plugin);
+            // 按优先级排序
+            this.middlewares.sort((a, b) => (a.priority || 100) - (b.priority || 100));
+        }
+    }
+    /**
+     * 批量注册插件
+     */
+    registerPlugins(plugins) {
+        plugins.forEach((plugin) => this.registerPlugin(plugin));
+    }
+    /**
+     * 获取转换器
+     */
+    getConverter(tag) {
+        return this.converters.get(tag);
+    }
+    /**
+     * 移除插件
+     */
+    unregisterPlugin(name) {
+        const plugin = this.plugins.get(name);
+        if (!plugin)
+            return false;
+        // 从转换器中移除
+        if (this.isConverterPlugin(plugin)) {
+            plugin.supportedTags?.forEach((tag) => {
+                if (this.converters.get(tag) === plugin) {
+                    this.converters.delete(tag);
+                }
+            });
+        }
+        // 从中间件中移除
+        if (this.isMiddlewarePlugin(plugin)) {
+            const index = this.middlewares.indexOf(plugin);
+            if (index !== -1) {
+                this.middlewares.splice(index, 1);
+            }
+        }
+        this.plugins.delete(name);
+        return true;
+    }
+    /**
+     * 获取已注册的插件列表
+     */
+    getRegisteredPlugins() {
+        return Array.from(this.plugins.values());
+    }
+    /**
+     * 清空所有插件
+     */
+    clear() {
+        this.plugins.clear();
+        this.converters.clear();
+        this.middlewares.length = 0;
+    }
+    /**
+     * 处理数据 - 四阶段处理流程
+     */
+    async process(tokens, context, options = {}) {
+        try {
+            // 初始化插件
+            await this.initializePlugins(context);
+            // 1. Tokenize 阶段
+            let processedTokens = tokens;
+            for (const middleware of this.middlewares) {
+                if (middleware.onTokenize) {
+                    processedTokens = await middleware.onTokenize(processedTokens, context);
+                }
+            }
+            // 2. AST 生成阶段
+            let ast = this.generateAST(processedTokens);
+            for (const middleware of this.middlewares) {
+                if (middleware.onAstGenerate) {
+                    ast = await middleware.onAstGenerate(ast, context);
+                }
+            }
+            // 3. 转换阶段
+            let result = this.convertAST(ast, context);
+            for (const middleware of this.middlewares) {
+                if (middleware.onConvert) {
+                    result = await middleware.onConvert(result, context);
+                }
+            }
+            // 4. 完成阶段
+            let finalResult = result;
+            for (const middleware of this.middlewares) {
+                if (middleware.onComplete) {
+                    finalResult = await middleware.onComplete(finalResult, context);
+                }
+            }
+            // 更新统计信息
+            if (options.enableStats) {
+                context.stats.endTime = Date.now();
+                context.stats.processedTokens = processedTokens.length;
+            }
+            return finalResult;
+        }
+        catch (error) {
+            // 错误处理
+            const err = error;
+            context.errors.push(err);
+            for (const middleware of this.middlewares) {
+                if (middleware.onError) {
+                    await middleware.onError(err, context);
+                }
+            }
+            throw err;
+        }
+        finally {
+            // 销毁插件
+            await this.destroyPlugins(context);
+        }
+    }
+    /**
+     * 生成 AST
+     */
+    generateAST(tokens) {
+        const stack = [];
+        let root = undefined;
+        let current = null;
+        for (const token of tokens) {
+            if (token.type === "open") {
+                const newElement = {
+                    tag: token.tag,
+                    attributes: token.attributes || {},
+                    children: [],
+                };
+                if (!root) {
+                    root = newElement;
+                }
+                else {
+                    current?.children?.push(newElement);
+                }
+                stack.push(newElement);
+                current = newElement;
+            }
+            else if (token.type === "text") {
+                if (current) {
+                    current.value = token.value;
+                }
+            }
+            else if (token.type === "close") {
+                stack.pop();
+                current = stack[stack.length - 1] || null;
+            }
+        }
+        if (!root) {
+            throw new Error("无法生成有效的 AST");
+        }
+        return root;
+    }
+    /**
+     * 转换 AST
+     */
+    convertAST(ast, context) {
+        const converter = this.getConverter(ast.tag);
+        if (converter) {
+            return converter.convert(ast, context);
+        }
+        // 如果没有专门的转换器，使用通用转换逻辑
+        return this.convertGeneric(ast, context);
+    }
+    /**
+     * 通用转换逻辑
+     */
+    convertGeneric(ast, context) {
+        const result = {};
+        // 复制属性
+        if (ast.attributes) {
+            Object.entries(ast.attributes).forEach(([key, value]) => {
+                result[key] = value;
+            });
+        }
+        // 如果有值，直接返回值
+        if (ast.value !== undefined &&
+            (!ast.children || ast.children.length === 0)) {
+            return ast.value;
+        }
+        // 处理子元素
+        if (ast.children) {
+            ast.children.forEach((child) => {
+                if (child.tag) {
+                    const converted = this.convertAST(child, context);
+                    if (result[child.tag]) {
+                        // 如果已存在，转换为数组
+                        if (!Array.isArray(result[child.tag])) {
+                            result[child.tag] = [result[child.tag]];
+                        }
+                        result[child.tag].push(converted);
+                    }
+                    else {
+                        result[child.tag] = converted;
+                    }
+                }
+            });
+        }
+        return result;
+    }
+    /**
+     * 初始化插件
+     */
+    async initializePlugins(context) {
+        for (const plugin of this.plugins.values()) {
+            if (plugin.initialize) {
+                await plugin.initialize(context);
+            }
+        }
+    }
+    /**
+     * 销毁插件
+     */
+    async destroyPlugins(context) {
+        for (const plugin of this.plugins.values()) {
+            if (plugin.destroy) {
+                try {
+                    await plugin.destroy(context);
+                }
+                catch (error) {
+                    console.warn(`销毁插件 ${plugin.name} 时出错:`, error);
+                }
+            }
+        }
+    }
+    /**
+     * 检查是否为转换器插件
+     */
+    isConverterPlugin(plugin) {
+        return "convert" in plugin && typeof plugin.convert === "function";
+    }
+    /**
+     * 检查是否为中间件插件
+     */
+    isMiddlewarePlugin(plugin) {
+        return ("onTokenize" in plugin ||
+            "onAstGenerate" in plugin ||
+            "onConvert" in plugin ||
+            "onComplete" in plugin ||
+            "onError" in plugin);
+    }
+}

package/dist/core/xml-utils.d.ts

@@ -0,0 +1,41 @@
+import { Token } from "../types.js";
+/**
+ * XML 解析工具类
+ */
+export declare class XMLUtils {
+    /**
+     * 将 XML 内容转换为 Token 数组
+     */
+    static tokenizeXML(xmlContent: string): Token[];
+    /**
+     * 压缩 XML 字符串（移除多余空白）
+     */
+    static compressXML(xmlContent: string): string;
+    /**
+     * 格式化 XML 字符串（添加缩进）
+     */
+    static formatXML(xmlContent: string, indentSize?: number): string;
+    /**
+     * 验证 XML 格式
+     */
+    static validateXML(xmlContent: string): {
+        isValid: boolean;
+        error?: string;
+    };
+    /**
+     * 提取 XML 声明信息
+     */
+    static extractXMLDeclaration(xmlContent: string): {
+        version?: string;
+        encoding?: string;
+        standalone?: string;
+    };
+    /**
+     * 转义 XML 特殊字符
+     */
+    static escapeXML(text: string): string;
+    /**
+     * 反转义 XML 特殊字符
+     */
+    static unescapeXML(text: string): string;
+}

package/dist/core/xml-utils.js

@@ -0,0 +1,140 @@
+import { Parser } from "htmlparser2";
+/**
+ * XML 解析工具类
+ */
+export class XMLUtils {
+    /**
+     * 将 XML 内容转换为 Token 数组
+     */
+    static tokenizeXML(xmlContent) {
+        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(xmlContent);
+        parser.end();
+        return tokens;
+    }
+    /**
+     * 压缩 XML 字符串（移除多余空白）
+     */
+    static compressXML(xmlContent) {
+        return xmlContent
+            .replace(/>\s+</g, "><") // 移除标签间的空白
+            .replace(/\s+/g, " ") // 将多个空白字符替换为单个空格
+            .trim();
+    }
+    /**
+     * 格式化 XML 字符串（添加缩进）
+     */
+    static formatXML(xmlContent, indentSize = 2) {
+        const indent = " ".repeat(indentSize);
+        let formatted = "";
+        let depth = 0;
+        let inTag = false;
+        for (let i = 0; i < xmlContent.length; i++) {
+            const char = xmlContent[i];
+            const nextChar = xmlContent[i + 1];
+            if (char === "<") {
+                if (nextChar === "/") {
+                    // 闭合标签
+                    depth--;
+                    if (!inTag) {
+                        formatted += "\n" + indent.repeat(depth);
+                    }
+                }
+                else if (nextChar !== "?" && nextChar !== "!") {
+                    // 开始标签
+                    if (!inTag) {
+                        formatted += "\n" + indent.repeat(depth);
+                    }
+                    depth++;
+                }
+                inTag = true;
+            }
+            else if (char === ">") {
+                inTag = false;
+                if (nextChar === "<" && xmlContent[i + 2] === "/") {
+                    // 自闭合标签或紧跟闭合标签
+                    depth--;
+                }
+            }
+            formatted += char;
+        }
+        return formatted.trim();
+    }
+    /**
+     * 验证 XML 格式
+     */
+    static validateXML(xmlContent) {
+        try {
+            const parser = new Parser({}, { xmlMode: true });
+            parser.write(xmlContent);
+            parser.end();
+            return { isValid: true };
+        }
+        catch (error) {
+            return {
+                isValid: false,
+                error: error.message,
+            };
+        }
+    }
+    /**
+     * 提取 XML 声明信息
+     */
+    static extractXMLDeclaration(xmlContent) {
+        const declarationMatch = xmlContent.match(/<\?xml\s+([^>]+)\?>/);
+        if (!declarationMatch)
+            return {};
+        const declaration = declarationMatch[1];
+        const result = {};
+        const versionMatch = declaration.match(/version=["']([^"']+)["']/);
+        if (versionMatch)
+            result.version = versionMatch[1];
+        const encodingMatch = declaration.match(/encoding=["']([^"']+)["']/);
+        if (encodingMatch)
+            result.encoding = encodingMatch[1];
+        const standaloneMatch = declaration.match(/standalone=["']([^"']+)["']/);
+        if (standaloneMatch)
+            result.standalone = standaloneMatch[1];
+        return result;
+    }
+    /**
+     * 转义 XML 特殊字符
+     */
+    static escapeXML(text) {
+        return text
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/"/g, "&quot;")
+            .replace(/'/g, "&#39;");
+    }
+    /**
+     * 反转义 XML 特殊字符
+     */
+    static unescapeXML(text) {
+        return text
+            .replace(/&lt;/g, "<")
+            .replace(/&gt;/g, ">")
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'")
+            .replace(/&amp;/g, "&");
+    }
+}