@nokecy/qc-ui 1.0.66 → 1.0.67

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

@@ -0,0 +1,190 @@
+/**
+ * 正则表达式复杂度分析器
+ *
+ * @module RegexEditor/validation/complexity
+ * @description 分析正则表达式的复杂度,评估性能风险并提供优化建议
+ *
+ * @remarks
+ * 该模块通过遍历 AST 来统计以下复杂度指标:
+ * - 节点总数
+ * - 最大嵌套深度
+ * - 分支数量(alternation)
+ * - 量词数量(quantifier)
+ * - 捕获组数量
+ * - 字符类数量
+ *
+ * 基于这些指标计算:
+ * - 回溯风险等级(low/medium/high)
+ * - 性能评分(0-100分)
+ * - 优化建议列表
+ */
+
+import { traverseAST } from "./parser";
+/**
+ * 分析正则表达式复杂度
+ *
+ * @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;
+};
+export var 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 统计各项指标
+  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/esm/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/esm/components/RegexEditor/validation/parser.js

@@ -0,0 +1,123 @@
+/**
+ * 正则表达式解析器
+ *
+ * @module RegexEditor/validation/parser
+ * @description 基于 regexp-tree 的正则表达式解析器,提供 AST 解析和遍历功能
+ *
+ * @remarks
+ * 该模块封装了 regexp-tree 库,提供类型安全的解析和遍历功能。
+ * 主要功能:
+ * - 将正则表达式字符串解析为抽象语法树(AST)
+ * - 统一的错误处理和转换
+ * - AST 节点遍历工具
+ *
+ * @see https://github.com/DmitrySoshnikov/regexp-tree
+ */
+
+import { parse, traverse } from '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);
+ * }
+ * ```
+ */
+export var parseRegex = function parseRegex(pattern, flags) {
+  try {
+    // 空字符串特殊处理
+    if (pattern === '') {
+      // regexp-tree 可以解析空字符串,使用非捕获组表示
+      var _ast = parse('/(?:)/');
+      return {
+        success: true,
+        ast: _ast,
+        pattern: pattern
+      };
+    }
+
+    // 构建完整的正则表达式字符串
+    // regexp-tree 需要完整的 /pattern/flags 格式
+    var regexStr = flags ? "/".concat(pattern, "/").concat(flags) : "/".concat(pattern, "/");
+
+    // 尝试解析
+    var ast = 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);
+ *   }
+ * });
+ * ```
+ */
+export var traverseAST = function traverseAST(ast, handlers) {
+  // 安全处理空 AST
+  if (!ast) {
+    return;
+  }
+  try {
+    traverse(ast, handlers);
+  } catch (error) {
+    // 遍历错误时静默失败,避免影响主流程
+    console.error('AST traversal error:', error);
+  }
+};

package/dist/esm/components/RegexEditor/validation/types.d.ts

@@ -0,0 +1,145 @@
+/**
+ * 正则表达式验证引擎 - 类型定义
+ *
+ * @module RegexEditor/validation/types
+ * @description 定义正则表达式解析、验证、复杂度分析相关的核心类型
+ */
+/// <reference types="dist/esm/types/regexp-tree" />
+/// <reference types="regexp-tree" />
+/// <reference types="src/types/regexp-tree" />
+/**
+ * regexp-tree 的 AST 节点类型
+ *
+ * @remarks
+ * 使用 regexp-tree 库提供的官方类型定义。
+ * 节点包含 type, loc, expression 等属性,支持完整的类型推导。
+ *
+ * 注意: 'regexp-tree/ast' 子模块的类型声明在 src/types/regexp-tree-ast.d.ts 中定义
+ *
+ * @see https://github.com/DmitrySoshnikov/regexp-tree
+ */
+import type { AstNode, AstRegExp as RegExpAstNode } from 'regexp-tree/ast';
+export type ASTNode = AstNode;
+export type AstRegExp = RegExpAstNode;
+/**
+ * 正则表达式解析结果
+ *
+ * @interface ParseResult
+ * @property {boolean} success - 解析是否成功
+ * @property {ASTNode} [ast] - 抽象语法树节点（成功时存在）
+ * @property {string} pattern - 原始正则表达式字符串
+ * @property {RegexError} [error] - 解析错误信息（失败时存在）
+ *
+ * @example
+ * ```typescript
+ * const result = parseRegex('^LOT\\d{6}$');
+ * if (result.success) {
+ *   console.log(result.ast);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+export interface ParseResult {
+    success: boolean;
+    ast?: ASTNode;
+    pattern: string;
+    error?: RegexError;
+}
+/**
+ * 正则表达式验证结果
+ *
+ * @interface ValidationResult
+ * @property {boolean} valid - 验证是否通过（无错误,可能有警告）
+ * @property {RegexError[]} errors - 错误列表（仅包含 severity='error' 的项）
+ * @property {RegexError[]} warnings - 警告列表（仅包含 severity='warning' 的项）
+ * @property {RegexError[]} infos - 信息列表（仅包含 severity='info' 的项）
+ * @property {string} pattern - 被验证的正则表达式字符串
+ *
+ * @example
+ * ```typescript
+ * const result = validateRegex(pattern);
+ *
+ * if (result.errors.length > 0) {
+ *   console.error('验证失败:', result.errors);
+ * } else if (result.warnings.length > 0) {
+ *   console.warn('验证通过但有警告:', result.warnings);
+ * } else {
+ *   console.log('验证完全通过');
+ * }
+ * ```
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: RegexError[];
+    warnings: RegexError[];
+    infos: RegexError[];
+    pattern: string;
+}
+/**
+ * 正则表达式错误信息
+ *
+ * @interface RegexError
+ * @property {string} type - 错误类型标识符
+ * @property {string} message - 人类可读的错误描述
+ * @property {Object} position - 错误位置范围
+ * @property {number} position.start - 起始位置（字符索引）
+ * @property {number} position.end - 结束位置（字符索引）
+ * @property {'error' | 'warning' | 'info'} severity - 严重程度
+ * @property {string} [suggestion] - 修复建议（可选）
+ *
+ * @example
+ * ```typescript
+ * const error: RegexError = {
+ *   type: 'empty_group',
+ *   message: '空的捕获组,建议使用非捕获组 (?:)',
+ *   position: { start: 5, end: 7 },
+ *   severity: 'warning',
+ *   suggestion: '使用 (?:) 代替 ()'
+ * };
+ * ```
+ */
+export interface RegexError {
+    type: string;
+    message: string;
+    position: {
+        start: number;
+        end: number;
+    };
+    severity: 'error' | 'warning' | 'info';
+    suggestion?: string;
+}
+/**
+ * 正则表达式复杂度指标
+ *
+ * @interface ComplexityMetrics
+ * @property {number} nodeCount - AST 节点总数
+ * @property {number} depth - 最大嵌套深度
+ * @property {number} alternationCount - 分支数量 (|)
+ * @property {number} quantifierCount - 量词数量 (+, *, {n,m})
+ * @property {number} groupCount - 捕获组数量
+ * @property {number} characterClassCount - 字符类数量 ([...])
+ * @property {'low' | 'medium' | 'high'} backtrackingRisk - 回溯风险等级
+ * @property {number} performanceScore - 性能评分 (0-100)
+ * @property {string[]} suggestions - 优化建议列表
+ *
+ * @example
+ * ```typescript
+ * const metrics = analyzeComplexity(ast);
+ * if (metrics.backtrackingRisk === 'high') {
+ *   console.warn('高回溯风险:', metrics.suggestions);
+ * }
+ * console.log('性能评分:', metrics.performanceScore);
+ * ```
+ */
+export interface ComplexityMetrics {
+    nodeCount: number;
+    depth: number;
+    alternationCount: number;
+    quantifierCount: number;
+    groupCount: number;
+    characterClassCount: number;
+    backtrackingRisk: 'low' | 'medium' | 'high';
+    performanceScore: number;
+    suggestions: string[];
+}

package/dist/esm/components/RegexEditor/validation/types.js

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

package/dist/esm/components/RegexEditor/validation/validator.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 正则表达式语法验证器
+ *
+ * @module RegexEditor/validation/validator
+ * @description 检测正则表达式的常见语法错误和安全问题
+ *
+ * @remarks
+ * 该模块基于 regexp-tree AST 提供以下验证规则:
+ * 1. 空捕获组检测 - 检测 () 并建议使用 (?:)
+ * 2. 无效量词检测 - 检测 {min,max} 中 min > max
+ * 3. 嵌套量词检测 - 检测 (a+)+ 等导致灾难性回溯的模式
+ * 4. 未闭合组检测 - 通过解析错误自动检测
+ *
+ * @see {@link parseRegex} 用于解析正则表达式
+ */
+import type { ASTNode, RegexError, ValidationResult } from './types';
+/**
+ * 验证正则表达式 AST
+ *
+ * @param ast - 抽象语法树节点
+ * @returns {RegexError[]} 错误和警告列表
+ *
+ * @remarks
+ * 该函数遍历 AST 节点,应用以下验证规则:
+ * - 空捕获组 (警告)
+ * - 无效量词 (错误)
+ * - 嵌套量词/灾难性回溯 (错误)
+ *
+ * @example
+ * ```typescript
+ * const result = parseRegex('()test');
+ * const errors = validateRegex(result.ast!);
+ * console.log(errors); // [{ type: 'empty_group', severity: 'warning', ... }]
+ * ```
+ */
+export declare const validateRegex: (ast: ASTNode) => RegexError[];
+/**
+ * 整合验证流程: 解析 + 语法验证
+ *
+ * @param pattern - 正则表达式字符串
+ * @param flags - 可选的正则表达式标志
+ * @returns {ValidationResult} 完整的验证结果
+ *
+ * @remarks
+ * 该函数整合了以下步骤:
+ * 1. 解析正则表达式 {@link parseRegex}
+ * 2. 语法验证 {@link validateRegex}
+ * 3. 分类错误、警告和信息
+ *
+ * @example
+ * ```typescript
+ * const result = validatePattern('^LOT\\d{6}$');
+ * if (result.valid) {
+ *   console.log('验证通过');
+ * } else {
+ *   console.error('错误:', result.errors);
+ * }
+ * ```
+ */
+export declare const validatePattern: (pattern: string, flags?: string) => ValidationResult;