@nokecy/qc-ui-components 0.0.0-stage → 2.0.0-beta.1

package/dist/cjs/components/RegexEditor/templates/types.d.ts

@@ -0,0 +1,111 @@
+/**
+ * 正则表达式模板系统 - 类型定义
+ *
+ * @module RegexEditor/templates/types
+ * @description 定义正则表达式模板库相关的核心类型
+ */
+/**
+ * 正则表达式模板
+ *
+ * @interface RegexTemplate
+ * @property {string} id - 模板唯一标识符
+ * @property {string} name - 模板名称（显示用）
+ * @property {string} pattern - 正则表达式字符串
+ * @property {string} description - 模板详细描述
+ * @property {TemplateCategory} category - 模板分类
+ * @property {string[]} tags - 标签列表（用于搜索和过滤）
+ * @property {Object} examples - 匹配示例
+ * @property {string[]} examples.valid - 有效匹配示例
+ * @property {string[]} examples.invalid - 无效匹配示例
+ * @property {'simple' | 'medium' | 'complex'} complexity - 复杂度等级
+ * @property {number} [useCount] - 使用次数（用于热门排序）
+ * @property {Date} [lastUsed] - 最后使用时间
+ * @property {boolean} [isCustom] - 是否为用户自定义模板
+ *
+ * @example
+ * ```typescript
+ * const lotNumberTemplate: RegexTemplate = {
+ *   id: 'lot-number',
+ *   name: '批次号',
+ *   pattern: '^LOT\\d{6}$',
+ *   description: '标准批次号格式：LOT + 6位数字',
+ *   category: TemplateCategory.BUSINESS,
+ *   tags: ['批次', 'LOT', '业务'],
+ *   examples: {
+ *     valid: ['LOT123456', 'LOT000001'],
+ *     invalid: ['LOT12345', 'lot123456', 'LOT1234567']
+ *   },
+ *   complexity: 'simple',
+ *   useCount: 42,
+ *   lastUsed: new Date('2025-01-27'),
+ *   isCustom: false
+ * };
+ * ```
+ */
+export interface RegexTemplate {
+    id: string;
+    name: string;
+    pattern: string;
+    description: string;
+    category: TemplateCategory;
+    tags: string[];
+    examples: {
+        valid: string[];
+        invalid: string[];
+    };
+    complexity: 'simple' | 'medium' | 'complex';
+    useCount?: number;
+    lastUsed?: Date;
+    isCustom?: boolean;
+}
+/**
+ * 模板分类枚举
+ *
+ * @enum TemplateCategory
+ * @property {string} BUSINESS - 业务相关（批次号、订单号等）
+ * @property {string} COMMON - 通用模式（邮箱、电话等）
+ * @property {string} DATE_TIME - 日期时间格式
+ * @property {string} NUMBER - 数字格式（整数、小数、科学计数法等）
+ * @property {string} TEXT - 文本格式（中文、英文、特殊字符等）
+ * @property {string} VALIDATION - 数据验证（长度、范围等）
+ * @property {string} EXTRACTION - 数据提取（提取特定部分）
+ * @property {string} CUSTOM - 用户自定义
+ *
+ * @example
+ * ```typescript
+ * // 按分类过滤模板
+ * const businessTemplates = allTemplates.filter(
+ *   t => t.category === TemplateCategory.BUSINESS
+ * );
+ *
+ * // 获取分类显示名称
+ * const categoryNames = {
+ *   [TemplateCategory.BUSINESS]: '业务模板',
+ *   [TemplateCategory.COMMON]: '通用模板',
+ *   [TemplateCategory.DATE_TIME]: '日期时间',
+ *   [TemplateCategory.NUMBER]: '数字格式',
+ *   [TemplateCategory.TEXT]: '文本格式',
+ *   [TemplateCategory.VALIDATION]: '数据验证',
+ *   [TemplateCategory.EXTRACTION]: '数据提取',
+ *   [TemplateCategory.CUSTOM]: '自定义'
+ * };
+ * ```
+ */
+export declare enum TemplateCategory {
+    /** 业务相关模板 */
+    BUSINESS = "business",
+    /** 通用模式模板 */
+    COMMON = "common",
+    /** 日期时间格式 */
+    DATE_TIME = "datetime",
+    /** 数字格式 */
+    NUMBER = "number",
+    /** 文本格式 */
+    TEXT = "text",
+    /** 数据验证 */
+    VALIDATION = "validation",
+    /** 数据提取 */
+    EXTRACTION = "extraction",
+    /** 用户自定义 */
+    CUSTOM = "custom"
+}

package/dist/cjs/components/RegexEditor/templates/types.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TemplateCategory = void 0;
+/**
+ * 正则表达式模板系统 - 类型定义
+ *
+ * @module RegexEditor/templates/types
+ * @description 定义正则表达式模板库相关的核心类型
+ */
+/**
+ * 正则表达式模板
+ *
+ * @interface RegexTemplate
+ * @property {string} id - 模板唯一标识符
+ * @property {string} name - 模板名称（显示用）
+ * @property {string} pattern - 正则表达式字符串
+ * @property {string} description - 模板详细描述
+ * @property {TemplateCategory} category - 模板分类
+ * @property {string[]} tags - 标签列表（用于搜索和过滤）
+ * @property {Object} examples - 匹配示例
+ * @property {string[]} examples.valid - 有效匹配示例
+ * @property {string[]} examples.invalid - 无效匹配示例
+ * @property {'simple' | 'medium' | 'complex'} complexity - 复杂度等级
+ * @property {number} [useCount] - 使用次数（用于热门排序）
+ * @property {Date} [lastUsed] - 最后使用时间
+ * @property {boolean} [isCustom] - 是否为用户自定义模板
+ *
+ * @example
+ * ```typescript
+ * const lotNumberTemplate: RegexTemplate = {
+ *   id: 'lot-number',
+ *   name: '批次号',
+ *   pattern: '^LOT\\d{6}$',
+ *   description: '标准批次号格式：LOT + 6位数字',
+ *   category: TemplateCategory.BUSINESS,
+ *   tags: ['批次', 'LOT', '业务'],
+ *   examples: {
+ *     valid: ['LOT123456', 'LOT000001'],
+ *     invalid: ['LOT12345', 'lot123456', 'LOT1234567']
+ *   },
+ *   complexity: 'simple',
+ *   useCount: 42,
+ *   lastUsed: new Date('2025-01-27'),
+ *   isCustom: false
+ * };
+ * ```
+ */
+/**
+ * 模板分类枚举
+ *
+ * @enum TemplateCategory
+ * @property {string} BUSINESS - 业务相关（批次号、订单号等）
+ * @property {string} COMMON - 通用模式（邮箱、电话等）
+ * @property {string} DATE_TIME - 日期时间格式
+ * @property {string} NUMBER - 数字格式（整数、小数、科学计数法等）
+ * @property {string} TEXT - 文本格式（中文、英文、特殊字符等）
+ * @property {string} VALIDATION - 数据验证（长度、范围等）
+ * @property {string} EXTRACTION - 数据提取（提取特定部分）
+ * @property {string} CUSTOM - 用户自定义
+ *
+ * @example
+ * ```typescript
+ * // 按分类过滤模板
+ * const businessTemplates = allTemplates.filter(
+ *   t => t.category === TemplateCategory.BUSINESS
+ * );
+ *
+ * // 获取分类显示名称
+ * const categoryNames = {
+ *   [TemplateCategory.BUSINESS]: '业务模板',
+ *   [TemplateCategory.COMMON]: '通用模板',
+ *   [TemplateCategory.DATE_TIME]: '日期时间',
+ *   [TemplateCategory.NUMBER]: '数字格式',
+ *   [TemplateCategory.TEXT]: '文本格式',
+ *   [TemplateCategory.VALIDATION]: '数据验证',
+ *   [TemplateCategory.EXTRACTION]: '数据提取',
+ *   [TemplateCategory.CUSTOM]: '自定义'
+ * };
+ * ```
+ */
+var TemplateCategory = exports.TemplateCategory = /*#__PURE__*/function (TemplateCategory) {
+  TemplateCategory["BUSINESS"] = "business";
+  TemplateCategory["COMMON"] = "common";
+  TemplateCategory["DATE_TIME"] = "datetime";
+  TemplateCategory["NUMBER"] = "number";
+  TemplateCategory["TEXT"] = "text";
+  TemplateCategory["VALIDATION"] = "validation";
+  TemplateCategory["EXTRACTION"] = "extraction";
+  TemplateCategory["CUSTOM"] = "custom";
+  return TemplateCategory;
+}({});

package/dist/cjs/components/RegexEditor/testing/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 正则表达式测试工具 - 类型定义
+ *
+ * @module RegexEditor/testing/types
+ * @description 定义正则表达式测试功能相关的核心类型
+ */
+/**
+ * 正则表达式测试结果
+ *
+ * @interface TestResult
+ * @property {string} input - 测试输入字符串
+ * @property {string[] | null} matches - 匹配结果数组（未匹配时为 null）
+ * @property {boolean} isMatch - 是否匹配成功
+ * @property {number} [executionTime] - 执行耗时（毫秒）
+ * @property {string} [error] - 执行错误信息（如果有）
+ * @property {Record<string, string>} [groups] - 命名捕获组结果
+ *
+ * @example
+ * ```typescript
+ * // 成功匹配的结果
+ * const successResult: TestResult = {
+ *   input: 'LOT123456',
+ *   matches: ['LOT123456', '123456'],
+ *   isMatch: true,
+ *   executionTime: 0.42,
+ *   groups: {
+ *     number: '123456'
+ *   }
+ * };
+ *
+ * // 未匹配的结果
+ * const failureResult: TestResult = {
+ *   input: 'LOT12345',
+ *   matches: null,
+ *   isMatch: false,
+ *   executionTime: 0.15
+ * };
+ *
+ * // 执行错误的结果
+ * const errorResult: TestResult = {
+ *   input: 'test',
+ *   matches: null,
+ *   isMatch: false,
+ *   error: 'Invalid regular expression'
+ * };
+ * ```
+ */
+export interface TestResult {
+    input: string;
+    matches: string[] | null;
+    isMatch: boolean;
+    executionTime?: number;
+    error?: string;
+    groups?: Record<string, string>;
+}

package/dist/cjs/components/RegexEditor/testing/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/cjs/components/RegexEditor/validation/complexity.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 正则表达式复杂度分析器
+ *
+ * @module RegexEditor/validation/complexity
+ * @description 分析正则表达式的复杂度,评估性能风险并提供优化建议
+ *
+ * @remarks
+ * 该模块通过遍历 AST 来统计以下复杂度指标:
+ * - 节点总数
+ * - 最大嵌套深度
+ * - 分支数量(alternation)
+ * - 量词数量(quantifier)
+ * - 捕获组数量
+ * - 字符类数量
+ *
+ * 基于这些指标计算:
+ * - 回溯风险等级(low/medium/high)
+ * - 性能评分(0-100分)
+ * - 优化建议列表
+ */
+import type { ASTNode, ComplexityMetrics } from './types';
+export declare const analyzeComplexity: (ast: ASTNode) => ComplexityMetrics;

package/dist/cjs/components/RegexEditor/validation/complexity.js

@@ -0,0 +1,196 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.analyzeComplexity = void 0;
+var _parser = require("./parser");
+/**
+ * 正则表达式复杂度分析器
+ *
+ * @module RegexEditor/validation/complexity
+ * @description 分析正则表达式的复杂度,评估性能风险并提供优化建议
+ *
+ * @remarks
+ * 该模块通过遍历 AST 来统计以下复杂度指标:
+ * - 节点总数
+ * - 最大嵌套深度
+ * - 分支数量(alternation)
+ * - 量词数量(quantifier)
+ * - 捕获组数量
+ * - 字符类数量
+ *
+ * 基于这些指标计算:
+ * - 回溯风险等级(low/medium/high)
+ * - 性能评分(0-100分)
+ * - 优化建议列表
+ */
+
+/**
+ * 分析正则表达式复杂度
+ *
+ * @param ast - 正则表达式的抽象语法树
+ * @returns {ComplexityMetrics} 复杂度指标
+ *
+ * @example
+ * ```typescript
+ * const result = parseRegex('(a+)+b');
+ * const metrics = analyzeComplexity(result.ast!);
+ *
+ * if (metrics.backtrackingRisk === 'high') {
+ *   console.warn('警告: 高回溯风险');
+ *   console.log('建议:', metrics.suggestions);
+ * }
+ *
+ * console.log('性能评分:', metrics.performanceScore);
+ * ```
+ */
+/**
+ * 计算节点深度
+ * 通过递归遍历 parentPath 计算从根节点到当前节点的深度
+ */
+var calculateDepth = function calculateDepth(path) {
+  var depth = 1;
+  var currentPath = path;
+
+  // 递归向上查找父节点
+  while (currentPath.parentPath) {
+    depth++;
+    currentPath = currentPath.parentPath;
+  }
+  return depth;
+};
+var analyzeComplexity = exports.analyzeComplexity = function analyzeComplexity(ast) {
+  // 统计指标
+  var nodeCount = 0;
+  var maxDepth = 1; // 初始深度为1
+  var alternationCount = 0;
+  var quantifierCount = 0;
+  var groupCount = 0;
+  var characterClassCount = 0;
+  var nestedQuantifiers = 0;
+
+  // 遍历 AST 统计各项指标
+  (0, _parser.traverseAST)(ast, {
+    // 通配符: 统计所有节点
+    '*': function _(path) {
+      nodeCount++;
+
+      // 计算深度: 递归计算父节点数量
+      var depth = calculateDepth(path);
+      maxDepth = Math.max(maxDepth, depth);
+    },
+    // 分支(Disjunction): a|b|c
+    // 注意: regexp-tree 中使用 Disjunction 表示分支(|)
+    // 每个 Disjunction 节点有 left 和 right 两个分支
+    Disjunction: function Disjunction() {
+      alternationCount++;
+    },
+    // 量词(Repetition): +, *, ?, {n,m}
+    Repetition: function Repetition(path) {
+      var _path$parent, _path$node$expression;
+      quantifierCount++;
+
+      // 检测嵌套量词: (a+)+ 或 (a*)*
+      // 检查父节点是否也是量词
+      if (((_path$parent = path.parent) === null || _path$parent === void 0 ? void 0 : _path$parent.type) === 'Repetition') {
+        nestedQuantifiers++;
+      }
+
+      // 检查子节点是否包含量词
+      // 如果子节点是分组,且分组内有量词,也算嵌套
+      if (((_path$node$expression = path.node.expression) === null || _path$node$expression === void 0 ? void 0 : _path$node$expression.type) === 'Group') {
+        var _group$expression;
+        var group = path.node.expression;
+        if (((_group$expression = group.expression) === null || _group$expression === void 0 ? void 0 : _group$expression.type) === 'Repetition') {
+          nestedQuantifiers++;
+        }
+      }
+    },
+    // 捕获组(Group): (...)
+    Group: function Group() {
+      groupCount++;
+    },
+    // 字符类(CharacterClass): [abc], [a-z], [^0-9]
+    CharacterClass: function CharacterClass() {
+      characterClassCount++;
+    },
+    // 元字符: \d, \w, \s 等
+    // regexp-tree 将 \d 等解析为 type='Char', kind='meta' 的节点
+    Char: function Char(path) {
+      if (path.node.kind === 'meta') {
+        characterClassCount++;
+      }
+    }
+  });
+
+  // 计算回溯风险
+  var backtrackingRisk = 'low';
+  if (nestedQuantifiers > 0) {
+    // 嵌套量词必然导致高风险
+    backtrackingRisk = 'high';
+  } else if (alternationCount > 3 && quantifierCount > 5) {
+    // 多分支 + 多量词 = 中等风险
+    backtrackingRisk = 'medium';
+  } else if (alternationCount > 5 || quantifierCount > 10) {
+    // 单独过多分支或量词 = 中等风险
+    backtrackingRisk = 'medium';
+  }
+
+  // 计算性能评分 (0-100)
+  // 基础分: 100
+  // 扣分规则:
+  // - 每个节点 -0.5分
+  // - 每层嵌套深度 -2分
+  // - 每个分支 -3分
+  // - 每个量词 -1.5分
+  // - 每个嵌套量词 -30分 (灾难性回溯风险,重度惩罚)
+  var performanceScore = 100;
+  performanceScore -= nodeCount * 0.5;
+  performanceScore -= maxDepth * 2;
+  performanceScore -= alternationCount * 3;
+  performanceScore -= quantifierCount * 1.5;
+  performanceScore -= nestedQuantifiers * 30;
+
+  // 确保分数在 0-100 之间
+  performanceScore = Math.max(0, Math.min(100, performanceScore));
+
+  // 生成优化建议
+  var suggestions = [];
+
+  // 建议1: 嵌套量词
+  if (nestedQuantifiers > 0) {
+    suggestions.push('避免嵌套量词,考虑使用原子组或重新设计表达式');
+  }
+
+  // 建议2: 过多分支
+  if (alternationCount > 5) {
+    suggestions.push('过多的分支可能影响性能,考虑拆分或优化');
+  }
+
+  // 建议3: 表达式过于复杂
+  if (nodeCount > 50) {
+    suggestions.push('表达式过于复杂,建议拆分为多个简单的表达式');
+  }
+
+  // 建议4: 量词使用过多
+  if (quantifierCount > 10) {
+    suggestions.push('量词使用过多,考虑优化匹配逻辑');
+  }
+
+  // 建议5: 嵌套层级过深
+  if (maxDepth > 5) {
+    suggestions.push('嵌套层级过深,建议简化结构');
+  }
+  return {
+    nodeCount: nodeCount,
+    depth: maxDepth,
+    alternationCount: alternationCount,
+    quantifierCount: quantifierCount,
+    groupCount: groupCount,
+    characterClassCount: characterClassCount,
+    backtrackingRisk: backtrackingRisk,
+    performanceScore: Math.round(performanceScore),
+    suggestions: suggestions
+  };
+};

package/dist/cjs/components/RegexEditor/validation/parser.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 正则表达式解析器
+ *
+ * @module RegexEditor/validation/parser
+ * @description 基于 regexp-tree 的正则表达式解析器,提供 AST 解析和遍历功能
+ *
+ * @remarks
+ * 该模块封装了 regexp-tree 库,提供类型安全的解析和遍历功能。
+ * 主要功能:
+ * - 将正则表达式字符串解析为抽象语法树(AST)
+ * - 统一的错误处理和转换
+ * - AST 节点遍历工具
+ *
+ * @see https://github.com/DmitrySoshnikov/regexp-tree
+ */
+import type { ParseResult, ASTNode } from './types';
+/**
+ * 解析正则表达式
+ *
+ * @param pattern - 正则表达式字符串
+ * @param flags - 可选的正则表达式标志(g, i, m, s, u, y)
+ * @returns {ParseResult} 解析结果,包含 AST 或错误信息
+ *
+ * @example
+ * ```typescript
+ * const result = parseRegex('^LOT\\d{6}$');
+ * if (result.success) {
+ *   console.log('AST:', result.ast);
+ * } else {
+ *   console.error('Error:', result.error);
+ * }
+ * ```
+ */
+export declare const parseRegex: (pattern: string, flags?: string) => ParseResult;
+/**
+ * 遍历 AST 节点
+ *
+ * @param ast - 抽象语法树节点
+ * @param handlers - 节点类型处理器映射
+ *
+ * @example
+ * ```typescript
+ * const result = parseRegex('(\\d+)');
+ * const groups: any[] = [];
+ *
+ * traverseAST(result.ast!, {
+ *   Group(path) {
+ *     groups.push(path.node);
+ *   }
+ * });
+ * ```
+ */
+export declare const traverseAST: (ast: ASTNode | undefined, handlers: Record<string, (path: any) => void>) => void;

package/dist/cjs/components/RegexEditor/validation/parser.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.traverseAST = exports.parseRegex = void 0;
+var _regexpTree = require("regexp-tree");
+/**
+ * 正则表达式解析器
+ *
+ * @module RegexEditor/validation/parser
+ * @description 基于 regexp-tree 的正则表达式解析器,提供 AST 解析和遍历功能
+ *
+ * @remarks
+ * 该模块封装了 regexp-tree 库,提供类型安全的解析和遍历功能。
+ * 主要功能:
+ * - 将正则表达式字符串解析为抽象语法树(AST)
+ * - 统一的错误处理和转换
+ * - AST 节点遍历工具
+ *
+ * @see https://github.com/DmitrySoshnikov/regexp-tree
+ */
+
+/**
+ * 解析正则表达式
+ *
+ * @param pattern - 正则表达式字符串
+ * @param flags - 可选的正则表达式标志(g, i, m, s, u, y)
+ * @returns {ParseResult} 解析结果,包含 AST 或错误信息
+ *
+ * @example
+ * ```typescript
+ * const result = parseRegex('^LOT\\d{6}$');
+ * if (result.success) {
+ *   console.log('AST:', result.ast);
+ * } else {
+ *   console.error('Error:', result.error);
+ * }
+ * ```
+ */
+var parseRegex = exports.parseRegex = function parseRegex(pattern, flags) {
+  try {
+    // 空字符串特殊处理
+    if (pattern === '') {
+      // regexp-tree 可以解析空字符串,使用非捕获组表示
+      var _ast = (0, _regexpTree.parse)('/(?:)/');
+      return {
+        success: true,
+        ast: _ast,
+        pattern: pattern
+      };
+    }
+
+    // 构建完整的正则表达式字符串
+    // regexp-tree 需要完整的 /pattern/flags 格式
+    var regexStr = flags ? "/".concat(pattern, "/").concat(flags) : "/".concat(pattern, "/");
+
+    // 尝试解析
+    var ast = (0, _regexpTree.parse)(regexStr);
+    return {
+      success: true,
+      ast: ast,
+      pattern: pattern
+    };
+  } catch (error) {
+    // 提取错误信息
+    var errorMessage = error.message || '解析失败';
+
+    // 处理不同格式的位置信息
+    var startPos = 0;
+    var endPos = pattern.length;
+    if (error.position !== undefined) {
+      if (typeof error.position === 'number') {
+        startPos = error.position;
+        endPos = error.position + 1;
+      } else if (error.position.start !== undefined) {
+        startPos = error.position.start;
+        endPos = error.position.end || startPos + 1;
+      }
+    }
+
+    // 转换为标准错误格式
+    var regexError = {
+      type: 'syntax_error',
+      message: errorMessage,
+      position: {
+        start: startPos,
+        end: endPos
+      },
+      severity: 'error'
+    };
+    return {
+      success: false,
+      pattern: pattern,
+      error: regexError
+    };
+  }
+};
+
+/**
+ * 遍历 AST 节点
+ *
+ * @param ast - 抽象语法树节点
+ * @param handlers - 节点类型处理器映射
+ *
+ * @example
+ * ```typescript
+ * const result = parseRegex('(\\d+)');
+ * const groups: any[] = [];
+ *
+ * traverseAST(result.ast!, {
+ *   Group(path) {
+ *     groups.push(path.node);
+ *   }
+ * });
+ * ```
+ */
+var traverseAST = exports.traverseAST = function traverseAST(ast, handlers) {
+  // 安全处理空 AST
+  if (!ast) {
+    return;
+  }
+  try {
+    (0, _regexpTree.traverse)(ast, handlers);
+  } catch (error) {
+    // 遍历错误时静默失败,避免影响主流程
+    console.error('AST traversal error:', error);
+  }
+};