cuxml 2.1.1 → 2.1.3

package/README.md

@@ -3,17 +3,17 @@
 > CU: `'Can Use'` or `'customUI'`, whatever……
 
 [![npm version](https://badge.fury.io/js/cuxml.svg)](https://www.npmjs.com/package/cuxml)
-[![License](https://img.shields.io/npm/l/cuxml.svg)](LICENSE)
 
 **CUXML** 是一个专为 WPS Office JS 插件开发者设计的工具，用于处理 RibbonUI XML 文件。它可以显著简化开发流程，让你更专注于业务逻辑。
 
 ## ✨ 特性
 
 - 🔄 **XML 到 JavaScript 转换** - 自动将 RibbonUI XML 的回调函数配置转换为 JavaScript 代码
-- 🔍 **XML 合规性检查** - 全面检查 XML 文件是否符合 CustomUI 规范
+- 🔍 **XML 合规性检查** - 全面检查 XML 文件是否符合 CustomUI 规范，详细显示错误和警告
 - 👀 **文件监视** - 监视 XML 文件变化，自动重新转换
 - 📦 **模块化 API** - 提供完整的编程接口，支持同步和异步调用
 - 🔌 **MCP 支持** - 可作为 MCP 插件集成到 AI 工具链中
+- ⚡ **转换前自动检查** - 转换前自动运行检查，提高开发效率
 
 ## 📦 安装
 
@@ -34,22 +34,54 @@ cuxml -i ./ribbon.xml  # 输出到 ./ribbon_temp.js
 # 指定输出路径
 cuxml -i ./ribbon.xml -o ./ribbon.js
 
-# 监视模式（文件变化时自动转换）
-cuxml -i ./ribbon.xml -w  # 输出到 ./ribbon_temp.js
+# 监视模式（文件变化时自动转换，默认覆盖输出文件）
+cuxml -i ./ribbon.xml -w
+
+# 非 watch 模式下覆盖已存在的输出文件
+cuxml -i ./ribbon.xml -o ./ribbon.js --overwrite
 
 # 使用默认输入路径（当前目录下的 ribbon.xml）
 cuxml  # 需要在当前目录有 ribbon.xml 文件
+
+# 注意：转换前会自动进行 XML 检查，有错误时会阻止转换
+```
+
+**选项说明：**
+
+| 选项 | 说明 |
+|------|------|
+| `-i, --input` | 输入的 XML 文件路径 |
+| `-o, --output` | 输出的 JS 文件路径 |
+| `-w, --watch` | 监视文件变化并自动转换（自动覆盖） |
+| `--overwrite` | 覆盖输出文件（非 watch 模式使用） |
+
+#### convert 子命令
+
+```bash
+# 基本转换
+cuxml convert ./ribbon.xml
+
+# 指定输入输出
+cuxml convert ./ribbon.xml ./ribbon.js
+
+# 监视模式
+cuxml convert ./ribbon.xml ./ribbon.js -w
+
+# 非 watch 模式下覆盖文件
+cuxml convert ./ribbon.xml ./ribbon.js --overwrite
 ```
 
 #### 检查 XML 文件
 
 ```bash
 cuxml check ./ribbon.xml
-
-# 显示详细信息
-cuxml check ./ribbon.xml -v
 ```
 
+检查命令会自动显示详细的错误和警告信息，包括：
+- 错误类型和位置
+- 警告详情和该元素支持的所有属性（以表格形式显示）
+- 支持的属性会按 4 列格式化输出，便于快速查找
+
 #### 查看帮助
 
 ```bash
@@ -109,10 +141,6 @@ npm install @modelcontextprotocol/sdk
 }
 ```
 
-## 📖 详细文档
-
-完整的使用文档和技术细节请参考：[CUXML Agent 文档](./test/agent_new.md)
-
 ## 🔧 功能说明
 
 ### XML 到 JavaScript 转换
@@ -156,43 +184,9 @@ function handleClick(ctrl) {
 - ✅ 属性值类型验证
 - ✅ 元素不支持的属性检测
 
-## 📁 项目结构
-
-```
-cuxml/
-├── src/
-│   ├── api.js          # API 模块
-│   ├── checker.js      # XML 检查器
-│   ├── cli.js          # CLI 工具
-│   ├── converter.js    # 转换器
-│   ├── mcp.js          # MCP 插件
-│   ├── parser.js       # XML 解析器
-│   └── templates.js    # 模板生成器
-├── lib/
-│   ├── simpleTypes.json        # Simple Types 配置
-│   ├── clashAttributes.json    # 冲突属性配置
-│   ├── StDelegate.json        # 回调函数属性配置
-│   └── cbfTypes.json         # Callback 函数类型配置
-├── test/              # 测试文件和示例
-├── index.js           # 主入口
-└── package.json
-```
-
-## 🎯 最佳实践
-
-### 1. 文件组织
-
-```
-project/
-├── src/
-│   └── ribbon.xml          # RibbonUI 配置文件
-├── gen/
-│   └── ribbon_callbacks.js # 自动生成的回调函数
-├── main.js                 # 主逻辑文件
-└── package.json
-```
+检查命令会以表格形式显示该元素支持的所有属性，便于快速查找正确的属性名。
 
-### 2. 开发工作流
+### 开发工作流
 
 ```bash
 # 开发阶段：使用监视模式，实时更新
@@ -202,52 +196,19 @@ cuxml -i src/ribbon.xml -o gen/ribbon_callbacks.js -w
 cuxml check src/ribbon.xml && cuxml -i src/ribbon.xml -o gen/ribbon_callbacks.js
 ```
 
-### 3. 错误处理
-
-```javascript
-const cuxml = require('cuxml');
-
-try {
-  cuxml.check('./ribbon.xml');
-  cuxml.convert('./ribbon.xml', './ribbon.js');
-  console.log('✅ 转换成功！');
-} catch (error) {
-  console.error('❌ 转换失败：', error.message);
-  // 处理错误
-}
-```
-
 ## 🔗 相关资源
 
 - [Microsoft CustomUI 规范](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-customui/574eeee8-7a03-406a-b95f-f9e51e53dd9d)
 - [Simple Types 参考](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-customui/869c8c9a-45f8-4119-b068-f61e76d04322)
 - [WPS Office 开发文档](https://wps.cn/developer/)
-- [CUXML Agent 文档](./test/agent_new.md) - 完整的使用文档
-
-## 🤝 贡献
-
-欢迎贡献！请随时提交 Issue 或 Pull Request。
-
-## 📄 许可证
-
-[ISC](LICENSE)
 
 ## 📊 版本历史
 
-### v2.0.0 (2026-02-14)
-
-**重大更新：完全重构**
-
-- ✨ 全新的模块化架构
-- ✨ 完整的 API 模块（支持同步和异步）
-- ✨ 统一的 CLI 命令（`cuxml`）
-- ✨ MCP 协议支持
-- ✨ 完整的 JSDoc 文档
-- ✨ 改进的错误处理和日志输出
-- 🔧 优化项目结构
-- 🐛 修复多个已知问题
+### v2.1.3 (2026-04-20)
 
-### v1.0.x
+**功能增强**
 
-- 初始版本
-- 基本的 XML 转换和检查功能
+- ✨ 改进检查命令输出 - 支持的属性以表格形式显示，提高可读性
+- ✨ 转换前自动检查 - 转换前自动运行 XML 检查，有错误时阻止转换
+- ✨ 详细的警告信息 - 未知属性和不支持的属性会显示该元素支持的所有属性
+- 📝 更新 README 文档

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cuxml",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "description": "A tool to help use ribbon UI for your WPS Office Client JS add-in project.",
   "keywords": [
     "wps office",

package/src/checker.js

@@ -228,7 +228,22 @@ class XMLChecker {
                 .filter(r => r.warnings.length > 0)
                 .forEach(r => {
                     output += `  路径: ${r.xmlpath}\n`;
-                    r.warnings.forEach(w => output += `    - ${w}\n`);
+                    r.warnings.forEach(w => {
+                        output += `    - ${w}\n`;
+                        // 如果是未知属性或不支持的属性，列出该元素支持的所有属性
+                        if ((w.startsWith('未知属性') || w.includes('不支持的属性')) && r.nodeElement && r.nodeElement.name) {
+                            const elementName = r.nodeElement.name;
+                            const supportedAttrs = elementsAttributes[elementName];
+                            if (supportedAttrs && supportedAttrs.length > 0) {
+                                // 先对数组进行排序
+                                const sortedAttrs = [...supportedAttrs].sort();
+                                output += `      支持的属性:\n`;
+                                sortedAttrs.forEach(attr => {
+                                    output += `        - ${attr}\n`;
+                                });
+                            }
+                        }
+                    });
                 });
         }
 

package/src/cli.js

@@ -33,15 +33,20 @@ program
     .option('-i, --input <file>', '输入的 XML 文件路径', './ribbon.xml')
     .option('-o, --output <file>', '输出的 JS 文件路径')
     .option('-w, --watch', '监视文件变化并自动转换')
+    .option('--overwrite', '覆盖输出文件（非 watch 模式）')
     .action((options) => {
         const outputPath = options.output || getDefaultOutputPath(options.input);
         try {
+            const watchOptions = options.watch ? { overwrite: true } : { overwrite: options.overwrite };
+            
             if (options.watch) {
                 console.log('🚀 启动监视模式...\n');
-                CUXMLAPI.watch(options.input, outputPath);
+                CUXMLAPI.watch(options.input, outputPath, watchOptions);
             } else {
                 console.log('🔄 开始转换...\n');
-                const result = CUXMLAPI.convertSync(options.input, outputPath);
+                const result = CUXMLAPI.convertSync(options.input, outputPath, { 
+                    overwrite: options.overwrite 
+                });
                 
                 if (result.success) {
                     console.log(`✅ ${result.message}`);
@@ -62,29 +67,15 @@ program
     .command('check')
     .description('检查 XML 文件是否符合 CustomUI 规范')
     .argument('<xmlFile>', '要检查的 XML 文件路径')
-    .option('-v, --verbose', '显示详细信息')
-    .action((xmlFile, options) => {
+    .action((xmlFile) => {
         try {
             console.log('🔍 开始检查...\n');
-            
+
             const result = XMLChecker.checkWithSummary(xmlFile);
-            
-            if (options.verbose) {
-                console.log(XMLChecker.formatSummary(result));
-            } else {
-                console.log(`总节点数: ${result.totalNodes}`);
-                console.log(`通过: ${result.passed}`);
-                console.log(`错误: ${result.errors}`);
-                console.log(`警告: ${result.warnings}`);
-                
-                if (result.errors === 0 && result.warnings === 0) {
-                    console.log('\n✅ 检查通过！');
-                } else if (result.errors === 0) {
-                    console.log('\n⚠️  检查通过，但有警告');
-                } else {
-                    console.log('\n❌ 检查失败，发现错误');
-                    process.exit(1);
-                }
+            console.log(XMLChecker.formatSummary(result));
+
+            if (result.errors > 0) {
+                process.exit(1);
             }
         } catch (error) {
             console.error(`❌ 错误: ${error.message}`);
@@ -99,12 +90,14 @@ program
     .argument('<inputFile>', '输入的 XML 文件路径')
     .argument('[outputFile]', '输出的 JS 文件路径', './ribbon_temp.js')
     .option('-w, --watch', '监视文件变化并自动转换')
-    .option('--overwrite', '覆盖输出文件')
+    .option('--overwrite', '覆盖输出文件（非 watch 模式）')
     .action((inputFile, outputFile, options) => {
         try {
+            const watchOptions = options.watch ? { overwrite: true } : { overwrite: options.overwrite };
+            
             if (options.watch) {
                 console.log('🚀 启动监视模式...\n');
-                CUXMLAPI.watch(inputFile, outputFile, { overwrite: options.overwrite });
+                CUXMLAPI.watch(inputFile, outputFile, watchOptions);
             } else {
                 console.log('🔄 开始转换...\n');
                 const result = CUXMLAPI.convertSync(inputFile, outputFile, { 

package/src/converter.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const lodash = require('lodash');
 const XMLParser = require('./parser');
+const XMLChecker = require('./checker');
 const { generateCallbackTemplate, processFunctionName } = require('./templates');
 
 /**
@@ -40,6 +41,19 @@ class XMLConverter {
             throw new Error(`输入文件不存在: ${inputPath}`);
         }
 
+        // 先进行 XML 检查
+        const checkSummary = XMLChecker.checkWithSummary(inputPath);
+
+        // 显示检查结果
+        if (!options.silent) {
+            if (checkSummary.errors > 0) {
+                console.log(XMLChecker.formatSummary(checkSummary));
+                throw new Error('XML 检查失败，存在错误');
+            } else if (checkSummary.warnings > 0) {
+                console.log(XMLChecker.formatSummary(checkSummary));
+            }
+        }
+
         // 加载配置
         const clashAttributes = require('../lib/clashAttributes.json').crashs;
         const stDelegate = require('../lib/StDelegate.json');

package/src/templates.js

@@ -12,18 +12,11 @@ function generateCallbackTemplate(functionName, controls = []) {
     // 如果控件数量为 0 或 1，生成简化版本的函数
     if (controls.length <= 1) {
         return `/**
- * @param {RibbonUI} control 控件对象，代表一个菜单控件元素对象（如 button、group 等）
- * @note 
- *  - 这是控件的回调函数，不应该在其他 JS 文件中调用这个函数
- *  - 尽量立即完成，避免写长耗时代码。
+ * @param {RibbonUI} control 控件对象
  *  
- *  生成时间: ${new Date().toLocaleString()}
+ *  ${new Date().toLocaleString()}
  */
 function ${functionName}(control) {
-
-    // code here
-
-    // 避免 UI 报错，总是返回 true
     return true;
 }
 `;
@@ -31,16 +24,16 @@ function ${functionName}(control) {
 
     // 多个控件使用时，生成 switch case 结构
     const cases = controls.map(control => {
-        return `        // xmlPath: ${control.xmlPath}\n        case "${control.id}":\n            // TODO: 实现控件逻辑\n            break;`;
+        return `        // xmlPath: ${control.xmlPath}\n        case "${control.id}":\n\n            break;`;
     });
 
     return `/**
- * @param {RibbonUI} control 控件对象，代表一个菜单控件元素对象（如 button、group 等）
+ * @param {RibbonUI} control 控件对象
  * @note 
- *  - 这是控件的回调函数，不应该在其他 JS 文件中调用这个函数
+ *  - 这是控件的回调函数
  *  - 尽量立即完成，避免写长耗时代码。
  *  
- *  生成时间: ${new Date().toLocaleString()}
+ *  ${new Date().toLocaleString()}
  */
 function ${functionName}(control) {
 

package/test/Agents.md

@@ -1,76 +0,0 @@
-# CUXML Agent
-
-## 1. 简介
-
-CUXML 是一个处理 RibbonUI XML 文件的工具。
-
-> [ribbon](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-customui/574eeee8-7a03-406a-b95f-f9e51e53dd9d)
-
-## CUXML 的功能包括：
-
-- 将 RibbonUI 的 XML 文件转换为 callback function。
-- 检查 RibbonUI 的 XML 文件是否合法：
-    - 检查 XML 文件是否符合规范。
-    - 检查 XML 文件是否有重复的 ID。
-    - 检查 XML 文件是否有冲突的属性。比如：label 和 getLabel. 参考：[冲突的属性](../clashAttributes.json)
-    - 检查 XML tag 的嵌套合规性。比如：button 不能嵌套在 button 中。
-    - 等等，可补充
-- 监视 RibbonUI 文件的变化，并自动转换为 callback function 到指定文件。
-
-### callback function 的处理
-
-- 将 XML 文件转换为 callback function 的代码，放在一个单独的文件中，比如：`ribbon_temp.js`。
-- 如果callback function 的名称带有"."连接符，则截取"."之后的字符串作为callback function 的名称。比如：`onClick.button1` 转换为 `button1`,最终得到 `function button1(ctrol){}`。
-
-### 参考的源文件
-
-- xml: [xml](./ribbon.xml)
-- js: [js](./ribbon.js)
-- 转换模版: [template](./template.js)
-
-#### 哪些属性可以被转换为 callback function
-
-可以参考 [常见属性的callback function](../StDelegate.json)
-
-## 2. 使用方法
-
-### 命令行
-
-```bash
-cuxml -h
-```
-> -h 显示帮助信息
-
-```bash
-cuxml -i ./ribbon.xml -o ./ribbon.js [-w]
-```
-> -i 指定输入文件，默认是当前目录下的 ribbon.xml。
->
-> -o 指定输出文件，默认是当前目录下的 ribbon_temp.js。
->
-> -w 监视文件的变化，并自动转换.
-
-```bash
-cuxml -c ./ribbon.xml
-```
-> -c ,check, 检查 XML 文件是否合法。
-
-### API
-
-```js
-const cuxml = require('cuxml');
-// convert
-cuxml.convert('./ribbon.xml', './ribbon.js');
-// check
-cuxml.check(xmlString｜xmlFile);
-```
-
-### MCP
-
-将其开发为一个 MCP 插件，可供其他工具调用。
-
-MCP 提供的 API 包括：
-
-- `convert(inputFile, outputFile)`: 将 XML 文件转换为 JavaScript 文件。
-- `check(xmlString｜xmlFile)`: 检查 XML 字符串是否合法。
-

package/test/agent_new.md

@@ -1,286 +0,0 @@
-# CUXML Agent
-
-## 📌 简介
-
-CUXML 是一个专为 WPS Office JS 插件开发者设计的工具，用于处理 RibbonUI XML 文件。它可以显著简化开发流程，让你更专注于业务逻辑而不是重复的代码编写。
-
-> 📖 参考文档：[Microsoft CustomUI 规范](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-customui/574eeee8-7a03-406a-b95f-f9e51e53dd9d)
-
----
-
-## ✨ 核心功能
-
-### 1. 🔄 XML 到 JavaScript 的转换
-
-将 RibbonUI XML 文件中的回调函数配置自动转换为 JavaScript 函数代码，大幅减少手工编码工作。
-
-**特性：**
-- 智能解析 XML 中的回调函数属性
-- 生成标准化的 JavaScript 函数模板
-- 支持自动函数名处理（带 `.` 连接符的属性名会被截取）
-- 支持监视文件变化，自动重新转换
-
-### 2. 🔍 XML 合规性检查
-
-全面检查 XML 文件是否符合 CustomUI 规范，提前发现潜在问题。
-
-**检查项目：**
-- ✅ XML 语法规范性
-- ✅ ID 唯一性检查（防止重复 ID）
-- ✅ 属性冲突检测（如 `label` 和 `getLabel` 不能同时存在）
-- ✅ 标签嵌套合规性（如 `button` 不能嵌套在 `button` 中）
-- ✅ 属性值类型验证（基于 Simple Types 规范）
-- ✅ 其他自定义规则验证
-
----
-
-## 🚀 快速开始
-
-### 安装
-
-```bash
-npm install -g cuxml
-```
-
-### 命令行使用
-
-#### 查看帮助信息
-
-```bash
-cuxml -h
-```
-
-#### 转换 XML 文件
-
-```bash
-# 基本用法
-cuxml -i ./ribbon.xml -o ./ribbon.js
-
-# 使用默认路径（当前目录下的 ribbon.xml -> ribbon_temp.js）
-cuxml
-
-# 监视模式（文件变化时自动转换）
-cuxml -i ./ribbon.xml -o ./ribbon.js -w
-```
-
-**参数说明：**
-- `-i, --input <file>`: 指定输入的 XML 文件路径，默认为 `./ribbon.xml`
-- `-o, --output <file>`: 指定输出的 JS 文件路径，默认为 `./ribbon_temp.js`
-- `-w, --watch`: 启用监视模式，自动检测文件变化并重新转换
-- `-h, --help`: 显示帮助信息
-
-#### 检查 XML 文件
-
-```bash
-cuxml -c ./ribbon.xml
-```
-
-**参数说明：**
-- `-c, --check <file>`: 检查指定的 XML 文件是否符合规范
-
-### API 使用
-
-```javascript
-const cuxml = require('cuxml');
-
-// 转换 XML 到 JavaScript
-cuxml.convert('./ribbon.xml', './ribbon.js');
-
-// 检查 XML 文件（支持文件路径或 XML 字符串）
-cuxml.check('./ribbon.xml');
-// 或
-cuxml.check('<customUI xmlns="...">...</customUI>');
-```
-
----
-
-## 📦 MCP 插件
-
-CUXML 还可以作为一个 MCP (Model Context Protocol) 插件使用，方便集成到 AI 工具链中。
-
-### 可用的 MCP API
-
-```javascript
-// 转换 XML 文件为 JavaScript
-mcp.convert(inputFile, outputFile);
-
-// 检查 XML 文件或字符串是否合法
-mcp.check(xmlString | xmlFile);
-```
-
-**使用场景：**
-- AI 辅助生成 RibbonUI XML 后自动转换
-- 自动化构建流程中的代码生成
-- CI/CD 流程中的 XML 验证
-
----
-
-## 🔧 技术细节
-
-### Callback Function 转换规则
-
-1. **函数名处理**
-   - 如果属性名包含 `.` 分隔符，自动提取最后一部分作为函数名
-   - 例如：`onClick.button1` → `function button1(control) {}`
-
-2. **函数签名**
-   - 所有生成的回调函数都遵循统一的签名
-   - 函数接收一个 `control` 参数，表示触发事件的控件对象
-
-3. **输出文件**
-   - 生成的代码会写入到指定的 JS 文件中
-   - 默认输出为当前目录的 `ribbon_temp.js`
-
-### 支持的回调函数属性
-
-所有支持转换为 callback function 的属性都定义在配置文件中，详细信息请参考：
-
-📄 **参考文件：** [StDelegate.json](../StDelegate.json)
-
-常见的回调函数属性包括：
-- `onAction` - 按钮点击事件
-- `getLabel` - 动态获取标签文本
-- `getImage` - 动态获取图标
-- `getEnabled` - 动态获取启用状态
-- `getVisible` - 动态获取可见性
-- 等等...
-
-### XML 检查规则
-
-#### 属性冲突检测
-
-参考配置文件中的冲突属性定义：
-
-📄 **参考文件：** [clashAttributes.json](../clashAttributes.json)
-
-**常见冲突示例：**
-- `label` vs `getLabel`
-- `image` vs `getImage`
-- `screentip` vs `getScreentip`
-- `supertip` vs `getSupertip`
-- `enabled` vs `getEnabled`
-- `visible` vs `getVisible`
-
-#### 标签嵌套规则
-
-严格遵循 CustomUI 的标签嵌套规范：
-- `button` 不能包含其他按钮
-- `tab` 必须包含在 `ribbon` 或 `ribbon.tabs` 中
-- `group` 必须包含在 `tab` 中
-- 等等...
-
-#### Simple Types 支持
-
-支持 http://schemas.microsoft.com/office/2006/01/customui 命名空间下的所有 Simple Types。
-
-📄 **参考文件：** [simpleTypes.json](../simpleTypes.json)
-
-支持版本：
-- CustomUI 2007
-- CustomUI 2010
-- 其他兼容版本
-
----
-
-## 📁 示例文件
-
-项目提供了完整的示例文件，供参考和学习：
-
-### 示例文件列表
-
-- **XML 示例：** [ribbon.xml](./ribbon.xml) - 完整的 RibbonUI XML 配置示例
-- **JS 输出示例：** [ribbon.js](./ribbon.js) - 转换后的 JavaScript 函数代码
-- **转换模板：** [template.js](./template.js) - 回调函数生成模板
-
-### 快速体验
-
-1. 查看 `ribbon.xml` 了解 RibbonUI 的 XML 结构
-2. 运行 `cuxml -i ./test/ribbon.xml -o ./output.js` 进行转换
-3. 对比 `ribbon.js` 和生成的 `output.js` 理解转换规则
-4. 运行 `cuxml -c ./test/ribbon.xml` 进行 XML 检查
-
----
-
-## 🎯 最佳实践
-
-### 1. 文件组织
-
-```
-project/
-├── src/
-│   └── ribbon.xml          # RibbonUI 配置文件
-├── gen/
-│   └── ribbon_callbacks.js # 自动生成的回调函数
-├── main.js                 # 主逻辑文件
-└── package.json
-```
-
-### 2. 开发工作流
-
-```bash
-# 开发阶段：使用监视模式，实时更新
-cuxml -i src/ribbon.xml -o gen/ribbon_callbacks.js -w
-
-# 构建阶段：生成并验证
-cuxml -c src/ribbon.xml && cuxml -i src/ribbon.xml -o gen/ribbon_callbacks.js
-```
-
-### 3. 错误处理
-
-```javascript
-const cuxml = require('cuxml');
-
-try {
-  cuxml.check('./ribbon.xml');
-  cuxml.convert('./ribbon.xml', './ribbon.js');
-  console.log('✅ 转换成功！');
-} catch (error) {
-  console.error('❌ 转换失败：', error.message);
-  // 处理错误
-}
-```
-
-### 4. 自定义扩展
-
-虽然 CUXML 提供了自动生成的模板，但复杂的业务逻辑仍需手动编写：
-
-```javascript
-// 自动生成的基础模板
-function button1(control) {
-  // TODO: 实现按钮逻辑
-}
-
-// 手动添加的复杂逻辑
-function button1(control) {
-  const app = control.context;
-  const selection = app.Selection;
-  
-  // 复杂的业务逻辑
-  if (selection && selection.Type === 1) { // 文本选中
-    // 处理文本...
-  }
-}
-```
-
----
-
-## 🔗 相关资源
-
-- [Microsoft CustomUI 规范](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-customui/574eeee8-7a03-406a-b95f-f9e51e53dd9d)
-- [Simple Types 参考](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-customui/869c8c9a-45f8-4119-b068-f61e76d04322)
-- [WPS Office 开发文档](https://wps.cn/developer/)
-
----
-
-## 🤝 贡献与反馈
-
-如果您在使用过程中遇到问题或有改进建议，欢迎：
-
-- 提交 [Issue](https://github.com/YYago/cuxml/issues)
-- 发起 [Pull Request](https://github.com/YYago/cuxml/pulls)
-
----
-
-## 📄 许可证
-
-ISC

package/test/ribbon.js

@@ -1,174 +0,0 @@
-import Util from './js/util.js'
-import SystemDemo from './js/systemdemo.js'
-
-//这个函数在整个wps加载项中是第一个执行的
-function OnAddinLoad(ribbonUI) {
-  if (typeof window.Application.ribbonUI != 'object') {
-    window.Application.ribbonUI = ribbonUI
-  }
-
-  if (typeof window.Application.Enum != 'object') {
-    // 如果没有内置枚举值
-    window.Application.Enum = Util.WPS_Enum
-  }
-
-  //这几个导出函数是给外部业务系统调用的
-  window.openOfficeFileFromSystemDemo = SystemDemo.openOfficeFileFromSystemDemo
-  window.InvokeFromSystemDemo = SystemDemo.InvokeFromSystemDemo
-
-  window.Application.PluginStorage.setItem('EnableFlag', false) //往PluginStorage中设置一个标记，用于控制两个按钮的置灰
-  window.Application.PluginStorage.setItem('ApiEventFlag', false) //往PluginStorage中设置一个标记，用于控制ApiEvent的按钮label
-  return true
-}
-
-var WebNotifycount = 0
-function OnAction(control) {
-  const eleId = control.Id
-  switch (eleId) {
-    case 'btnShowMsg':
-      {
-        const doc = window.Application.ActiveDocument
-        if (!doc) {
-          alert('当前没有打开任何文档')
-          return
-        }
-        alert(doc.Name)
-      }
-      break
-    case 'btnIsEnbable': {
-      let bFlag = window.Application.PluginStorage.getItem('EnableFlag')
-      window.Application.PluginStorage.setItem('EnableFlag', !bFlag)
-
-      //通知wps刷新以下几个按饰的状态
-      window.Application.ribbonUI.InvalidateControl('btnIsEnbable')
-      window.Application.ribbonUI.InvalidateControl('btnShowDialog')
-      window.Application.ribbonUI.InvalidateControl('btnShowTaskPane')
-      //window.Application.ribbonUI.Invalidate(); 这行代码打开则是刷新所有的按钮状态
-      break
-    }
-    case 'btnShowDialog': {
-      window.Application.ShowDialog(
-        Util.GetUrlPath() + Util.GetRouterHash() + '/dialog',
-        '这是一个对话框网页',
-        400 * window.devicePixelRatio,
-        400 * window.devicePixelRatio,
-        false
-      )
-      break
-    }
-    case 'btnShowTaskPane':
-      {
-        let tsId = window.Application.PluginStorage.getItem('taskpane_id')
-        if (!tsId) {
-          let tskpane = window.Application.CreateTaskPane(Util.GetUrlPath() + Util.GetRouterHash() + '/taskpane')
-          let id = tskpane.ID
-          window.Application.PluginStorage.setItem('taskpane_id', id)
-          tskpane.Visible = true
-        } else {
-          let tskpane = window.Application.GetTaskPane(tsId)
-          tskpane.Visible = !tskpane.Visible
-        }
-      }
-      break
-    case 'btnApiEvent':
-      {
-        let bFlag = window.Application.PluginStorage.getItem('ApiEventFlag')
-        let bRegister = bFlag ? false : true
-        window.Application.PluginStorage.setItem('ApiEventFlag', bRegister)
-        if (bRegister) {
-          window.Application.ApiEvent.AddApiEventListener('DocumentNew', 'ribbon.OnNewDocumentApiEvent')
-        } else {
-          window.Application.ApiEvent.RemoveApiEventListener('DocumentNew', 'ribbon.OnNewDocumentApiEvent')
-        }
-
-        window.Application.ribbonUI.InvalidateControl('btnApiEvent')
-      }
-      break
-    case 'btnWebNotify':
-      {
-        let currentTime = new Date()
-        let timeStr =
-          currentTime.getHours() + ':' + currentTime.getMinutes() + ':' + currentTime.getSeconds()
-        window.Application.OAAssist.WebNotify(
-          '这行内容由wps加载项主动送达给业务系统，可以任意自定义, 比如时间值:' +
-            timeStr +
-            '，次数：' +
-            ++WebNotifycount,
-          true
-        )
-      }
-      break
-    default:
-      break
-  }
-  return true
-}
-
-function GetImage(control) {
-  const eleId = control.Id
-  switch (eleId) {
-    case 'btnShowMsg':
-      return 'images/1.svg'
-    case 'btnShowDialog':
-      return 'images/2.svg'
-    case 'btnShowTaskPane':
-      return 'images/3.svg'
-    default:
-  }
-  return 'images/newFromTemp.svg'
-}
-
-function OnGetEnabled(control) {
-  const eleId = control.Id
-  switch (eleId) {
-    case 'btnShowMsg':
-      return true
-    case 'btnShowDialog': {
-      let bFlag = window.Application.PluginStorage.getItem('EnableFlag')
-      return bFlag
-    }
-    case 'btnShowTaskPane': {
-      let bFlag = window.Application.PluginStorage.getItem('EnableFlag')
-      return bFlag
-    }
-    default:
-      break
-  }
-  return true
-}
-
-function OnGetVisible(control) {
-  const eleId = control.Id
-  console.log(eleId)
-  return true
-}
-
-function OnGetLabel(control) {
-  const eleId = control.Id
-  switch (eleId) {
-    case 'btnIsEnbable': {
-      let bFlag = window.Application.PluginStorage.getItem('EnableFlag')
-      return bFlag ? '按钮Disable' : '按钮Enable'
-    }
-    case 'btnApiEvent': {
-      let bFlag = window.Application.PluginStorage.getItem('ApiEventFlag')
-      return bFlag ? '清除新建文件事件' : '注册新建文件事件'
-    }
-  }
-  return ''
-}
-
-function OnNewDocumentApiEvent(doc) {
-  alert('新建文件事件响应，取文件名: ' + doc.Name)
-}
-
-//这些函数是给wps客户端调用的
-export default {
-  OnAddinLoad,
-  OnAction,
-  GetImage,
-  OnGetEnabled,
-  OnGetVisible,
-  OnGetLabel,
-  OnNewDocumentApiEvent
-}

package/test/ribbon.xml

@@ -1,16 +0,0 @@
-<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" onLoad="ribbon.OnAddinLoad">
-    <ribbon startFromScratch="false">
-        <tabs>
-            <tab id="wpsAddinTab" label="wps加载项示例">
-				<group id="btnDemoGroup" label="group1">
-                    <button id="btnShowMsg" label="弹出消息框" onAction="ribbon.OnAction" getEnabled="ribbon.OnGetEnabled"  getImage="ribbon.GetImage" visible="true" size="large"/>
-                    <button id="btnIsEnbable" getLabel="ribbon.OnGetLabel" onAction="ribbon.OnAction" enabled="true"  getImage="ribbon.GetImage" visible="true" size="large"/>
-                    <button id="btnShowDialog" label="弹对话框网页" onAction="ribbon.OnAction" getEnabled="ribbon.OnGetEnabled"  getImage="ribbon.GetImage" getVisible="ribbon.OnGetVisible" size="large"/>
-                    <button id="btnShowTaskPane" label="弹任务窗格网页" onAction="ribbon.OnAction" getEnabled="ribbon.OnGetEnabled"  getImage="ribbon.GetImage" getVisible="ribbon.OnGetVisible" size="large"/>
-                    <button id="btnApiEvent" getLabel="ribbon.OnGetLabel" onAction="ribbon.OnAction" getEnabled="ribbon.OnGetEnabled"  getImage="ribbon.GetImage" getVisible="ribbon.OnGetVisible" size="large"/>
-                    <button id="btnWebNotify" label="给业务系统发通知" onAction="ribbon.OnAction" enabled="true"  getImage="ribbon.GetImage" getVisible="ribbon.OnGetVisible" size="large"/>
-				</group>
-            </tab>
-        </tabs>
-    </ribbon>
-</customUI>

package/test/test.js

@@ -1,325 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require('fs');
-const path = require('path');
-const cuxml = require('../index.js');
-
-// 测试结果目录
-const RESULT_DIR = path.join(__dirname, 'result');
-
-// 确保结果目录存在
-if (!fs.existsSync(RESULT_DIR)) {
-    fs.mkdirSync(RESULT_DIR, { recursive: true });
-}
-
-// 测试结果收集
-const testResults = [];
-
-/**
- * 记录测试结果
- */
-function logTest(name, success, message, data = null) {
-    const result = {
-        name,
-        success,
-        message,
-        data,
-        timestamp: new Date().toISOString()
-    };
-    testResults.push(result);
-    
-    const icon = success ? '✅' : '❌';
-    console.log(`${icon} ${name}: ${message}`);
-    if (data) {
-        console.log(`   ${JSON.stringify(data)}`);
-    }
-}
-
-/**
- * 清理测试文件
- */
-function cleanup() {
-    const files = [
-        path.join(RESULT_DIR, 'output1.js'),
-        path.join(RESULT_DIR, 'output2.js'),
-        path.join(RESULT_DIR, 'ribbon_temp.js')
-    ];
-    files.forEach(file => {
-        if (fs.existsSync(file)) {
-            fs.unlinkSync(file);
-        }
-    });
-}
-
-/**
- * 测试 1: 检查 XML 文件（同步）
- */
-async function test1_checkXMLSync() {
-    try {
-        const result = cuxml.checkSync(path.join(__dirname, 'ribbon.xml'));
-        logTest(
-            'XML 检查（同步）',
-            result.success,
-            `检查完成: ${result.passed}/${result.totalNodes} 通过`,
-            { errors: result.errors, warnings: result.warnings }
-        );
-        return result.success;
-    } catch (error) {
-        logTest('XML 检查（同步）', false, error.message);
-        return false;
-    }
-}
-
-/**
- * 测试 2: 检查 XML 文件（异步）
- */
-async function test2_checkXMLAsync() {
-    try {
-        const result = await cuxml.check(path.join(__dirname, 'ribbon.xml'));
-        logTest(
-            'XML 检查（异步）',
-            result.success,
-            `检查完成: ${result.passed}/${result.totalNodes} 通过`,
-            { errors: result.errors, warnings: result.warnings }
-        );
-        return result.success;
-    } catch (error) {
-        logTest('XML 检查（异步）', false, error.message);
-        return false;
-    }
-}
-
-/**
- * 测试 3: 转换 XML 到 JavaScript（同步）
- */
-async function test3_convertSync() {
-    try {
-        const inputFile = path.join(__dirname, 'ribbon.xml');
-        const outputFile = path.join(RESULT_DIR, 'output1.js');
-        
-        const result = cuxml.convertSync(inputFile, outputFile);
-        
-        const fileExists = fs.existsSync(outputFile);
-        logTest(
-            'XML 转换（同步）',
-            result.success && fileExists,
-            `生成 ${result.functionsGenerated} 个回调函数`,
-            { outputPath: result.outputPath, fileExists }
-        );
-        
-        return result.success && fileExists;
-    } catch (error) {
-        logTest('XML 转换（同步）', false, error.message);
-        return false;
-    }
-}
-
-/**
- * 测试 4: 转换 XML 到 JavaScript（异步）
- */
-async function test4_convertAsync() {
-    try {
-        const inputFile = path.join(__dirname, 'ribbon.xml');
-        const outputFile = path.join(RESULT_DIR, 'output2.js');
-        
-        const result = await cuxml.convert(inputFile, outputFile);
-        
-        const fileExists = fs.existsSync(outputFile);
-        logTest(
-            'XML 转换（异步）',
-            result.success && fileExists,
-            `生成 ${result.functionsGenerated} 个回调函数`,
-            { outputPath: result.outputPath, fileExists }
-        );
-        
-        return result.success && fileExists;
-    } catch (error) {
-        logTest('XML 转换（异步）', false, error.message);
-        return false;
-    }
-}
-
-/**
- * 测试 5: 检查 XML 字符串
- */
-async function test5_checkXMLString() {
-    try {
-        const xmlString = fs.readFileSync(path.join(__dirname, 'ribbon.xml'), 'utf-8');
-        const result = cuxml.checkSync(xmlString);
-        
-        logTest(
-            'XML 字符串检查',
-            result.success,
-            `检查完成: ${result.passed}/${result.totalNodes} 通过`,
-            { errors: result.errors, warnings: result.warnings }
-        );
-        
-        return result.success;
-    } catch (error) {
-        logTest('XML 字符串检查', false, error.message);
-        return false;
-    }
-}
-
-/**
- * 测试 6: 格式化检查结果
- */
-async function test6_formatCheckResult() {
-    try {
-        const inputFile = path.join(__dirname, 'ribbon.xml');
-        const result = cuxml.checkSync(inputFile, { detailed: true });
-        const formatted = cuxml.formatCheckResult(result);
-        
-        const hasFormat = typeof formatted === 'string' && formatted.length > 0;
-        logTest(
-            '格式化检查结果',
-            hasFormat,
-            `格式化输出长度: ${formatted.length} 字符`,
-            { outputLength: formatted.length }
-        );
-        
-        return hasFormat;
-    } catch (error) {
-        logTest('格式化检查结果', false, error.message);
-        return false;
-    }
-}
-
-/**
- * 测试 7: 输出文件内容验证
- */
-async function test7_verifyOutputContent() {
-    try {
-        const outputFile = path.join(RESULT_DIR, 'output1.js');
-        
-        if (!fs.existsSync(outputFile)) {
-            logTest('输出文件内容验证', false, '输出文件不存在');
-            return false;
-        }
-        
-        const content = fs.readFileSync(outputFile, 'utf-8');
-        
-        // 检查是否包含预期的函数
-        const expectedFunctions = ['OnAddinLoad', 'OnGetLabel', 'OnGetEnabled', 'OnGetVisible'];
-        const foundFunctions = expectedFunctions.filter(fn => content.includes(`function ${fn}`));
-        
-        const allFound = foundFunctions.length === expectedFunctions.length;
-        logTest(
-            '输出文件内容验证',
-            allFound,
-            `找到 ${foundFunctions.length}/${expectedFunctions.length} 个预期函数`,
-            { foundFunctions, expectedFunctions }
-        );
-        
-        return allFound;
-    } catch (error) {
-        logTest('输出文件内容验证', false, error.message);
-        return false;
-    }
-}
-
-/**
- * 保存测试结果
- */
-function saveResults() {
-    const resultFile = path.join(RESULT_DIR, 'test_results.json');
-    const successCount = testResults.filter(r => r.success).length;
-    const totalCount = testResults.length;
-    
-    const summary = {
-        totalTests: totalCount,
-        successTests: successCount,
-        failedTests: totalCount - successCount,
-        successRate: `${((successCount / totalCount) * 100).toFixed(2)}%`,
-        timestamp: new Date().toISOString(),
-        tests: testResults
-    };
-    
-    fs.writeFileSync(resultFile, JSON.stringify(summary, null, 2));
-    
-    // 保存 Markdown 格式的报告
-    const mdReport = generateMarkdownReport(summary);
-    const mdFile = path.join(RESULT_DIR, 'test_report.md');
-    fs.writeFileSync(mdFile, mdReport);
-    
-    console.log('\n📊 测试报告已保存:');
-    console.log(`   JSON: ${resultFile}`);
-    console.log(`   Markdown: ${mdFile}`);
-}
-
-/**
- * 生成 Markdown 报告
- */
-function generateMarkdownReport(summary) {
-    return `# CUXML v2.0.0 测试报告
-
-**测试时间**: ${summary.timestamp}
-**测试通过率**: ${summary.successRate} (${summary.successTests}/${summary.totalTests})
-
-## 测试结果概览
-
-| 测试名称 | 状态 | 消息 |
-|---------|------|------|
-${summary.tests.map(test => 
-    `| ${test.name} | ${test.success ? '✅ 通过' : '❌ 失败'} | ${test.message} |`
-).join('\n')}
-
-## 详细测试结果
-
-${summary.tests.map(test => `
-### ${test.name}
-
-- **状态**: ${test.success ? '✅ 通过' : '❌ 失败'}
-- **消息**: ${test.message}
-- **时间**: ${test.timestamp}
-${test.data ? `- **数据**: \`${JSON.stringify(test.data)}\`` : ''}
-`).join('\n')}
-
----
-
-## 统计信息
-
-- 总测试数: ${summary.totalTests}
-- 成功: ${summary.successTests}
-- 失败: ${summary.failedTests}
-- 成功率: ${summary.successRate}
-`;
-}
-
-/**
- * 运行所有测试
- */
-async function runAllTests() {
-    console.log('🧪 开始 CUXML v2.0.0 功能测试\n');
-    console.log('='.repeat(60));
-    
-    // 清理之前的测试文件
-    cleanup();
-    
-    // 运行测试
-    const tests = [
-        test1_checkXMLSync,
-        test2_checkXMLAsync,
-        test3_convertSync,
-        test4_convertAsync,
-        test5_checkXMLString,
-        test6_formatCheckResult,
-        test7_verifyOutputContent
-    ];
-    
-    for (const test of tests) {
-        await test();
-    }
-    
-    console.log('\n' + '='.repeat(60));
-    console.log(`✅ 测试完成: ${testResults.filter(r => r.success).length}/${testResults.length} 通过`);
-    
-    // 保存测试结果
-    saveResults();
-}
-
-// 运行测试
-runAllTests().catch(error => {
-    console.error('❌ 测试运行失败:', error);
-    process.exit(1);
-});