trackswap 0.0.2 → 0.0.3

package/dist/core/processor.js

@@ -1,265 +0,0 @@
-/**
- * 通用处理器 - 负责管理插件和处理流程
- */
-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.js

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

package/dist/types.js

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