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

package/dist/cjs/RuleBuilder/types/index.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MatchOperator = exports.MatchLogic = void 0;
+/**
+ * 规则构建器类型定义
+ *
+ * ⚠️ 重要：与后端定义完全一致
+ * - 后端 Domain: Burn.Abp.RuleEngine.Domain.Shared (Rule, RuleGroup)
+ * - 后端 DTO: Burn.Abp.LabelManagement.Application.Contracts.RuleEngine (RuleDto, RuleGroupDto)
+ *
+ * JSON 序列化属性名：
+ * - fieldName (不是 FieldName)
+ * - operator (不是 Operator)
+ * - value, value2, valueField
+ * - logic, rules, groups
+ */
+/**
+ * 操作符显示信息
+ */
+/**
+ * 匹配操作符枚举
+ *
+ * 对应后端: Burn.Abp.RuleEngine.Domain.Shared.MatchOperator
+ */
+var MatchOperator = exports.MatchOperator = /*#__PURE__*/function (MatchOperator) {
+  MatchOperator[MatchOperator["Equals"] = 0] = "Equals";
+  MatchOperator[MatchOperator["NotEquals"] = 1] = "NotEquals";
+  MatchOperator[MatchOperator["GreaterThan"] = 2] = "GreaterThan";
+  MatchOperator[MatchOperator["GreaterThanOrEqual"] = 3] = "GreaterThanOrEqual";
+  MatchOperator[MatchOperator["LessThan"] = 4] = "LessThan";
+  MatchOperator[MatchOperator["LessThanOrEqual"] = 5] = "LessThanOrEqual";
+  MatchOperator[MatchOperator["In"] = 6] = "In";
+  MatchOperator[MatchOperator["NotIn"] = 7] = "NotIn";
+  MatchOperator[MatchOperator["Between"] = 8] = "Between";
+  MatchOperator[MatchOperator["Like"] = 9] = "Like";
+  MatchOperator[MatchOperator["IsNull"] = 10] = "IsNull";
+  MatchOperator[MatchOperator["IsNotNull"] = 11] = "IsNotNull";
+  return MatchOperator;
+}({});
+/**
+ * 逻辑连接符枚举（与后端保持一致）
+ */
+var MatchLogic = exports.MatchLogic = /*#__PURE__*/function (MatchLogic) {
+  MatchLogic[MatchLogic["And"] = 0] = "And";
+  MatchLogic[MatchLogic["Or"] = 1] = "Or";
+  return MatchLogic;
+}({});
+/**
+ * 规则 DTO（与后端保持一致）
+ */
+/**
+ * 规则组 DTO（与后端保持一致）
+ */
+/**
+ * 字段数据类型
+ */
+/**
+ * 字段定义
+ */
+/**
+ * 验证错误
+ */
+/**
+ * 验证结果
+ */
+/**
+ * 规则构建器配置
+ */
+/**
+ * 规则构建器 Props
+ */
+/**
+ * 规则路径（用于定位嵌套规则）
+ */
+/**
+ * 规则构建器内部状态
+ */
+/**
+ * 规则构建器 Action
+ */

package/dist/cjs/RuleBuilder/utils/pathHelpers.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 路径寻址工具函数
+ * 用于定位和操作嵌套规则组中的规则
+ */
+import type { RuleDto, RuleGroupDto, RulePath } from '../types/index';
+/**
+ * 根据路径获取规则组
+ * @param group 根规则组
+ * @param path 路径数组
+ * @returns 目标规则组，如果路径无效则返回根组
+ */
+export declare function getRuleGroupByPath(group: RuleGroupDto, path: RulePath): RuleGroupDto;
+/**
+ * 根据路径获取规则
+ * @param group 根规则组
+ * @param path 路径数组（最后一个元素是规则索引）
+ * @returns 目标规则，如果路径无效则返回 undefined
+ */
+export declare function getRuleByPath(group: RuleGroupDto, path: RulePath): RuleDto | undefined;
+/**
+ * 根据路径更新规则（不可变更新）
+ * @param group 根规则组
+ * @param path 路径数组
+ * @param rule 新的规则对象
+ * @returns 更新后的规则组（新对象）
+ */
+export declare function updateRuleAtPath(group: RuleGroupDto, path: RulePath, rule: RuleDto): RuleGroupDto;
+/**
+ * 根据路径删除规则（不可变更新）
+ * @param group 根规则组
+ * @param path 路径数组
+ * @returns 更新后的规则组（新对象）
+ */
+export declare function deleteRuleAtPath(group: RuleGroupDto, path: RulePath): RuleGroupDto;
+/**
+ * 根据路径添加规则（不可变更新）
+ * @param group 根规则组
+ * @param path 路径数组（指向目标规则组）
+ * @param rule 新规则
+ * @returns 更新后的规则组（新对象）
+ */
+export declare function addRuleAtPath(group: RuleGroupDto, path: RulePath, rule: RuleDto): RuleGroupDto;
+/**
+ * 根据路径更新规则组（不可变更新）
+ * @param group 根规则组
+ * @param path 路径数组
+ * @param updatedGroup 新的规则组对象
+ * @returns 更新后的规则组（新对象）
+ */
+export declare function updateRuleGroupAtPath(group: RuleGroupDto, path: RulePath, updatedGroup: RuleGroupDto): RuleGroupDto;
+/**
+ * 根据路径删除规则组（不可变更新）
+ * @param group 根规则组
+ * @param path 路径数组
+ * @returns 更新后的规则组（新对象）
+ */
+export declare function deleteRuleGroupAtPath(group: RuleGroupDto, path: RulePath): RuleGroupDto;
+/**
+ * 根据路径添加规则组（不可变更新）
+ * @param group 根规则组
+ * @param path 路径数组（指向目标父规则组）
+ * @param newGroup 新规则组
+ * @returns 更新后的规则组（新对象）
+ */
+export declare function addRuleGroupAtPath(group: RuleGroupDto, path: RulePath, newGroup: RuleGroupDto): RuleGroupDto;

package/dist/cjs/RuleBuilder/utils/pathHelpers.js

@@ -0,0 +1,241 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addRuleAtPath = addRuleAtPath;
+exports.addRuleGroupAtPath = addRuleGroupAtPath;
+exports.deleteRuleAtPath = deleteRuleAtPath;
+exports.deleteRuleGroupAtPath = deleteRuleGroupAtPath;
+exports.getRuleByPath = getRuleByPath;
+exports.getRuleGroupByPath = getRuleGroupByPath;
+exports.updateRuleAtPath = updateRuleAtPath;
+exports.updateRuleGroupAtPath = updateRuleGroupAtPath;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+/**
+ * 路径寻址工具函数
+ * 用于定位和操作嵌套规则组中的规则
+ */
+
+/**
+ * 根据路径获取规则组
+ * @param group 根规则组
+ * @param path 路径数组
+ * @returns 目标规则组，如果路径无效则返回根组
+ */
+function getRuleGroupByPath(group, path) {
+  if (path.length === 0) {
+    return group;
+  }
+
+  // 路径格式: [groupIndex, groupIndex, ...]
+  // 例如: [0] 表示 groups[0], [0, 1] 表示 groups[0].groups[1]
+  var current = group;
+  for (var i = 0; i < path.length; i++) {
+    var index = path[i];
+    if (current.groups && current.groups[index]) {
+      current = current.groups[index];
+    } else {
+      // 路径无效，返回当前层级
+      return current;
+    }
+  }
+  return current;
+}
+
+/**
+ * 根据路径获取规则
+ * @param group 根规则组
+ * @param path 路径数组（最后一个元素是规则索引）
+ * @returns 目标规则，如果路径无效则返回 undefined
+ */
+function getRuleByPath(group, path) {
+  if (path.length === 0) {
+    return undefined;
+  }
+
+  // 分离出规则索引和组路径
+  var ruleIndex = path[path.length - 1];
+  var groupPath = path.slice(0, -1);
+  var targetGroup = getRuleGroupByPath(group, groupPath);
+  return targetGroup.rules[ruleIndex];
+}
+
+/**
+ * 根据路径更新规则（不可变更新）
+ * @param group 根规则组
+ * @param path 路径数组
+ * @param rule 新的规则对象
+ * @returns 更新后的规则组（新对象）
+ */
+function updateRuleAtPath(group, path, rule) {
+  if (path.length === 0) {
+    return group;
+  }
+  var ruleIndex = path[path.length - 1];
+  var groupPath = path.slice(0, -1);
+  if (groupPath.length === 0) {
+    // 更新根组中的规则
+    var newRules = _toConsumableArray(group.rules);
+    newRules[ruleIndex] = rule;
+    return _objectSpread(_objectSpread({}, group), {}, {
+      rules: newRules
+    });
+  }
+
+  // 递归更新嵌套组
+  var firstIndex = groupPath[0];
+  var restPath = groupPath.slice(1);
+  var newGroups = _toConsumableArray(group.groups);
+  newGroups[firstIndex] = updateRuleAtPath(newGroups[firstIndex], [].concat(_toConsumableArray(restPath), [ruleIndex]), rule);
+  return _objectSpread(_objectSpread({}, group), {}, {
+    groups: newGroups
+  });
+}
+
+/**
+ * 根据路径删除规则（不可变更新）
+ * @param group 根规则组
+ * @param path 路径数组
+ * @returns 更新后的规则组（新对象）
+ */
+function deleteRuleAtPath(group, path) {
+  if (path.length === 0) {
+    return group;
+  }
+  var ruleIndex = path[path.length - 1];
+  var groupPath = path.slice(0, -1);
+  if (groupPath.length === 0) {
+    // 删除根组中的规则
+    var newRules = group.rules.filter(function (_, index) {
+      return index !== ruleIndex;
+    });
+    return _objectSpread(_objectSpread({}, group), {}, {
+      rules: newRules
+    });
+  }
+
+  // 递归删除嵌套组中的规则
+  var firstIndex = groupPath[0];
+  var restPath = groupPath.slice(1);
+  var newGroups = _toConsumableArray(group.groups);
+  newGroups[firstIndex] = deleteRuleAtPath(newGroups[firstIndex], [].concat(_toConsumableArray(restPath), [ruleIndex]));
+  return _objectSpread(_objectSpread({}, group), {}, {
+    groups: newGroups
+  });
+}
+
+/**
+ * 根据路径添加规则（不可变更新）
+ * @param group 根规则组
+ * @param path 路径数组（指向目标规则组）
+ * @param rule 新规则
+ * @returns 更新后的规则组（新对象）
+ */
+function addRuleAtPath(group, path, rule) {
+  if (path.length === 0) {
+    // 添加到根组
+    return _objectSpread(_objectSpread({}, group), {}, {
+      rules: [].concat(_toConsumableArray(group.rules), [rule])
+    });
+  }
+
+  // 递归添加到嵌套组
+  var firstIndex = path[0];
+  var restPath = path.slice(1);
+  var newGroups = _toConsumableArray(group.groups);
+  newGroups[firstIndex] = addRuleAtPath(newGroups[firstIndex], restPath, rule);
+  return _objectSpread(_objectSpread({}, group), {}, {
+    groups: newGroups
+  });
+}
+
+/**
+ * 根据路径更新规则组（不可变更新）
+ * @param group 根规则组
+ * @param path 路径数组
+ * @param updatedGroup 新的规则组对象
+ * @returns 更新后的规则组（新对象）
+ */
+function updateRuleGroupAtPath(group, path, updatedGroup) {
+  if (path.length === 0) {
+    return updatedGroup;
+  }
+
+  // 递归更新嵌套组
+  var firstIndex = path[0];
+  var restPath = path.slice(1);
+  var newGroups = _toConsumableArray(group.groups);
+  newGroups[firstIndex] = updateRuleGroupAtPath(newGroups[firstIndex], restPath, updatedGroup);
+  return _objectSpread(_objectSpread({}, group), {}, {
+    groups: newGroups
+  });
+}
+
+/**
+ * 根据路径删除规则组（不可变更新）
+ * @param group 根规则组
+ * @param path 路径数组
+ * @returns 更新后的规则组（新对象）
+ */
+function deleteRuleGroupAtPath(group, path) {
+  if (path.length === 0) {
+    // 不能删除根组
+    return group;
+  }
+  if (path.length === 1) {
+    // 删除第一层的组
+    var groupIndex = path[0];
+    var _newGroups = group.groups.filter(function (_, index) {
+      return index !== groupIndex;
+    });
+    return _objectSpread(_objectSpread({}, group), {}, {
+      groups: _newGroups
+    });
+  }
+
+  // 递归删除嵌套组
+  var firstIndex = path[0];
+  var restPath = path.slice(1);
+  var newGroups = _toConsumableArray(group.groups);
+  newGroups[firstIndex] = deleteRuleGroupAtPath(newGroups[firstIndex], restPath);
+  return _objectSpread(_objectSpread({}, group), {}, {
+    groups: newGroups
+  });
+}
+
+/**
+ * 根据路径添加规则组（不可变更新）
+ * @param group 根规则组
+ * @param path 路径数组（指向目标父规则组）
+ * @param newGroup 新规则组
+ * @returns 更新后的规则组（新对象）
+ */
+function addRuleGroupAtPath(group, path, newGroup) {
+  if (path.length === 0) {
+    // 添加到根组
+    return _objectSpread(_objectSpread({}, group), {}, {
+      groups: [].concat(_toConsumableArray(group.groups), [newGroup])
+    });
+  }
+
+  // 递归添加到嵌套组
+  var firstIndex = path[0];
+  var restPath = path.slice(1);
+  var newGroups = _toConsumableArray(group.groups);
+  newGroups[firstIndex] = addRuleGroupAtPath(newGroups[firstIndex], restPath, newGroup);
+  return _objectSpread(_objectSpread({}, group), {}, {
+    groups: newGroups
+  });
+}

package/dist/cjs/RuleBuilder/utils/ruleHelpers.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 规则操作辅助函数
+ */
+import type { RuleDto, RuleGroupDto, MatchLogic, FieldDefinition } from '../types/index';
+/**
+ * 创建空规则
+ * @param fieldName 可选的字段名
+ * @returns 新的空规则对象
+ */
+export declare function createEmptyRule(fieldName?: string): RuleDto;
+/**
+ * 创建空规则组
+ * @param logic 逻辑关系，默认为 And
+ * @returns 新的空规则组对象
+ */
+export declare function createEmptyRuleGroup(logic?: MatchLogic): RuleGroupDto;
+/**
+ * 生成规则的可读描述
+ * @param rule 规则对象
+ * @param field 字段定义（可选）
+ * @returns 可读的规则描述字符串
+ */
+export declare function generateRuleDescription(rule: RuleDto, field?: FieldDefinition): string;
+/**
+ * 深度克隆规则组（用于不可变更新）
+ * @param group 规则组
+ * @returns 克隆后的规则组
+ */
+export declare function cloneRuleGroup(group: RuleGroupDto): RuleGroupDto;
+/**
+ * 检查规则组是否为空
+ * @param group 规则组
+ * @returns 是否为空
+ */
+export declare function isRuleGroupEmpty(group: RuleGroupDto): boolean;
+/**
+ * 统计规则组中的规则总数（递归）
+ * @param group 规则组
+ * @returns 规则总数
+ */
+export declare function countRules(group: RuleGroupDto): number;
+/**
+ * 获取规则组的最大嵌套深度
+ * @param group 规则组
+ * @returns 最大深度
+ */
+export declare function getMaxDepth(group: RuleGroupDto): number;

package/dist/cjs/RuleBuilder/utils/ruleHelpers.js

@@ -0,0 +1,154 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cloneRuleGroup = cloneRuleGroup;
+exports.countRules = countRules;
+exports.createEmptyRule = createEmptyRule;
+exports.createEmptyRuleGroup = createEmptyRuleGroup;
+exports.generateRuleDescription = generateRuleDescription;
+exports.getMaxDepth = getMaxDepth;
+exports.isRuleGroupEmpty = isRuleGroupEmpty;
+var _operators = require("../constants/operators");
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /**
+ * 规则操作辅助函数
+ */
+/**
+ * 创建空规则
+ * @param fieldName 可选的字段名
+ * @returns 新的空规则对象
+ */
+function createEmptyRule(fieldName) {
+  return {
+    fieldName: fieldName || '',
+    operator: 0,
+    // Equals
+    value: undefined,
+    value2: undefined
+  };
+}
+
+/**
+ * 创建空规则组
+ * @param logic 逻辑关系，默认为 And
+ * @returns 新的空规则组对象
+ */
+function createEmptyRuleGroup() {
+  var logic = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  return {
+    logic: logic,
+    rules: [],
+    groups: []
+  };
+}
+
+/**
+ * 生成规则的可读描述
+ * @param rule 规则对象
+ * @param field 字段定义（可选）
+ * @returns 可读的规则描述字符串
+ */
+function generateRuleDescription(rule, field) {
+  var fieldDisplayName = (field === null || field === void 0 ? void 0 : field.displayName) || rule.fieldName;
+  var operatorInfo = (0, _operators.getOperatorInfo)(rule.operator);
+  if (!fieldDisplayName) {
+    return '请选择字段';
+  }
+  if (!operatorInfo) {
+    return "".concat(fieldDisplayName, " (\u672A\u77E5\u64CD\u4F5C\u7B26)");
+  }
+
+  // IsNull 和 IsNotNull 不需要值
+  if (rule.operator === 10 || rule.operator === 11) {
+    return "".concat(fieldDisplayName, " ").concat(operatorInfo.label);
+  }
+
+  // Between 需要两个值
+  if (rule.operator === 8) {
+    if (rule.value !== undefined && rule.value2 !== undefined) {
+      return "".concat(fieldDisplayName, " ").concat(operatorInfo.label, " ").concat(rule.value, " \u548C ").concat(rule.value2);
+    }
+    return "".concat(fieldDisplayName, " ").concat(operatorInfo.label, " (\u8BF7\u8F93\u5165\u8303\u56F4)");
+  }
+
+  // In 和 NotIn 需要多个值
+  if (rule.operator === 6 || rule.operator === 7) {
+    if (Array.isArray(rule.value) && rule.value.length > 0) {
+      var valueStr = rule.value.join(', ');
+      return "".concat(fieldDisplayName, " ").concat(operatorInfo.label, " [").concat(valueStr, "]");
+    }
+    return "".concat(fieldDisplayName, " ").concat(operatorInfo.label, " (\u8BF7\u8F93\u5165\u503C\u5217\u8868)");
+  }
+
+  // 其他操作符需要单个值
+  if (rule.value !== undefined && rule.value !== null && rule.value !== '') {
+    return "".concat(fieldDisplayName, " ").concat(operatorInfo.symbol, " ").concat(rule.value);
+  }
+  return "".concat(fieldDisplayName, " ").concat(operatorInfo.label, " (\u8BF7\u8F93\u5165\u503C)");
+}
+
+/**
+ * 深度克隆规则组（用于不可变更新）
+ * @param group 规则组
+ * @returns 克隆后的规则组
+ */
+function cloneRuleGroup(group) {
+  return {
+    logic: group.logic,
+    rules: group.rules.map(function (rule) {
+      return _objectSpread({}, rule);
+    }),
+    groups: group.groups.map(function (g) {
+      return cloneRuleGroup(g);
+    })
+  };
+}
+
+/**
+ * 检查规则组是否为空
+ * @param group 规则组
+ * @returns 是否为空
+ */
+function isRuleGroupEmpty(group) {
+  return group.rules.length === 0 && group.groups.length === 0;
+}
+
+/**
+ * 统计规则组中的规则总数（递归）
+ * @param group 规则组
+ * @returns 规则总数
+ */
+function countRules(group) {
+  var count = group.rules.length;
+  group.groups.forEach(function (g) {
+    count += countRules(g);
+  });
+  return count;
+}
+
+/**
+ * 获取规则组的最大嵌套深度
+ * @param group 规则组
+ * @returns 最大深度
+ */
+function getMaxDepth(group) {
+  if (group.groups.length === 0) {
+    return 1;
+  }
+  var childDepths = group.groups.map(function (g) {
+    return getMaxDepth(g);
+  });
+  return 1 + Math.max.apply(Math, _toConsumableArray(childDepths));
+}

package/dist/cjs/RuleBuilder/utils/validation.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 规则验证逻辑
+ */
+import type { RuleDto, RuleGroupDto, FieldDefinition, ValidationResult, ValidationError } from '../types/index';
+/**
+ * 验证规则组
+ * @param group 规则组
+ * @param fields 字段定义列表
+ * @returns 验证结果
+ */
+export declare function validateRuleGroup(group: RuleGroupDto, fields: FieldDefinition[]): ValidationResult;
+/**
+ * 验证单条规则
+ * @param rule 规则
+ * @param fields 字段定义列表
+ * @returns 错误列表
+ */
+export declare function validateRule(rule: RuleDto, fields: FieldDefinition[]): ValidationError[];
+/**
+ * 简化的验证（只检查是否有致命错误）
+ * @param group 规则组
+ * @param fields 字段定义列表
+ * @returns 是否有效
+ */
+export declare function isRuleGroupValid(group: RuleGroupDto, fields: FieldDefinition[]): boolean;