@kmkf-fe-packages/kmkf-work-order-service-component 2.2.5-beta.4 → 2.2.5-beta.41

package/dist/esm/FlowTemplateDetailV2/components/FormRender/component-dependency-finder.d.ts

@@ -0,0 +1,75 @@
+/**
+ * 组件显隐依赖关系查找器 - TypeScript ES Module版本
+ * 根据配置文件递归查找组件的所有依赖关系
+ */
+import type { Config, DependencyGraph, CircularDependency, DependencyLevels, ComponentStat, DependencyOptions, DependencyAnalysis } from './types.js';
+/**
+ * 查找组件的所有依赖关系（递归）
+ * @param componentKey - 要查找依赖的组件key
+ * @param config - 显隐配置对象
+ * @param visited - 已访问的组件集合，用于避免循环依赖
+ * @param dependencies - 依赖组件集合
+ * @param options - 查找选项
+ * @returns 所有依赖组件的key数组
+ */
+export declare function findAllDependencies(componentKey: string, config: Config, visited?: Set<string>, dependencies?: Set<string>, options?: DependencyOptions): string[];
+/**
+ * 获取组件的直接依赖
+ * @param componentKey - 组件key
+ * @param config - 显隐配置对象
+ * @returns 直接依赖的组件key数组
+ */
+export declare function getDirectDependencies(componentKey: string, config: Config): string[];
+/**
+ * 构建整个依赖关系图
+ * @param config - 显隐配置对象
+ * @returns 依赖关系图，格式：{ componentKey: [依赖的组件数组] }
+ */
+export declare function buildDependencyGraph(config: Config): DependencyGraph;
+/**
+ * 检测循环依赖
+ * @param config - 显隐配置对象
+ * @returns 包含循环依赖的组件组
+ */
+export declare function detectCircularDependencies(config: Config): CircularDependency[];
+/**
+ * 打印依赖关系树
+ * @param componentKey - 组件key
+ * @param config - 显隐配置对象
+ * @param level - 缩进级别
+ * @param visited - 已访问的组件集合
+ */
+export declare function printDependencyTree(componentKey: string, config: Config, level?: number, visited?: Set<string>): void;
+/**
+ * 获取组件的依赖层级
+ * @param componentKey - 组件key
+ * @param config - 显隐配置对象
+ * @returns 依赖层级对象
+ */
+export declare function getDependencyLevels(componentKey: string, config: Config): DependencyLevels;
+/**
+ * 分析组件的完整依赖信息
+ * @param componentKey - 组件key
+ * @param config - 显隐配置对象
+ * @returns 完整的依赖分析结果
+ */
+export declare function analyzeDependency(componentKey: string, config: Config): DependencyAnalysis;
+/**
+ * 获取依赖统计信息
+ * @param config - 显隐配置对象
+ * @param topN - 返回前N个结果
+ * @returns 组件统计信息数组
+ */
+export declare function getDependencyStats(config: Config, topN?: number): {
+    mostDependencies: ComponentStat[];
+    mostDependedOn: ComponentStat[];
+};
+/**
+ * 验证配置文件格式
+ * @param config - 要验证的配置对象
+ * @returns 验证结果和错误信息
+ */
+export declare function validateConfig(config: unknown): {
+    isValid: boolean;
+    errors: string[];
+};

package/dist/esm/FlowTemplateDetailV2/components/FormRender/component-dependency-finder.js

@@ -0,0 +1,328 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+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; }
+/**
+ * 组件显隐依赖关系查找器 - TypeScript ES Module版本
+ * 根据配置文件递归查找组件的所有依赖关系
+ */
+
+/**
+ * 查找组件的所有依赖关系（递归）
+ * @param componentKey - 要查找依赖的组件key
+ * @param config - 显隐配置对象
+ * @param visited - 已访问的组件集合，用于避免循环依赖
+ * @param dependencies - 依赖组件集合
+ * @param options - 查找选项
+ * @returns 所有依赖组件的key数组
+ */
+export function findAllDependencies(componentKey, config) {
+  var visited = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Set();
+  var dependencies = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Set();
+  var options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  var _options$maxDepth = options.maxDepth,
+    maxDepth = _options$maxDepth === void 0 ? Infinity : _options$maxDepth;
+
+  // 如果已经访问过这个组件，直接返回（避免循环依赖）
+  if (visited.has(componentKey)) {
+    return Array.from(dependencies);
+  }
+
+  // 检查递归深度
+  if (visited.size >= maxDepth) {
+    return Array.from(dependencies);
+  }
+
+  // 标记当前组件为已访问
+  visited.add(componentKey);
+
+  // 获取当前组件的配置
+  var componentConfig = config[componentKey];
+
+  // 如果组件不存在配置，返回当前依赖列表
+  if (!componentConfig || !Array.isArray(componentConfig)) {
+    return Array.from(dependencies);
+  }
+
+  // 遍历组件的所有规则组
+  componentConfig.forEach(function (ruleGroup) {
+    if (ruleGroup.rules && Array.isArray(ruleGroup.rules)) {
+      // 遍历规则组中的所有规则
+      ruleGroup.rules.forEach(function (rule) {
+        if (rule.leftValue && typeof rule.leftValue === 'string') {
+          var dependencyKey = rule.leftValue;
+
+          // 添加直接依赖
+          dependencies.add(dependencyKey);
+
+          // 递归查找间接依赖
+          findAllDependencies(dependencyKey, config, visited, dependencies, options);
+        }
+      });
+    }
+  });
+  return Array.from(dependencies);
+}
+
+/**
+ * 获取组件的直接依赖
+ * @param componentKey - 组件key
+ * @param config - 显隐配置对象
+ * @returns 直接依赖的组件key数组
+ */
+export function getDirectDependencies(componentKey, config) {
+  var componentConfig = config[componentKey];
+  var dependencies = new Set();
+  if (!componentConfig || !Array.isArray(componentConfig)) {
+    return [];
+  }
+  componentConfig.forEach(function (ruleGroup) {
+    if (ruleGroup.rules && Array.isArray(ruleGroup.rules)) {
+      ruleGroup.rules.forEach(function (rule) {
+        if (rule.leftValue && typeof rule.leftValue === 'string') {
+          dependencies.add(rule.leftValue);
+        }
+      });
+    }
+  });
+  return Array.from(dependencies);
+}
+
+/**
+ * 构建整个依赖关系图
+ * @param config - 显隐配置对象
+ * @returns 依赖关系图，格式：{ componentKey: [依赖的组件数组] }
+ */
+export function buildDependencyGraph(config) {
+  var dependencyGraph = {};
+  Object.keys(config).forEach(function (componentKey) {
+    dependencyGraph[componentKey] = findAllDependencies(componentKey, config);
+  });
+  return dependencyGraph;
+}
+
+/**
+ * 检测循环依赖
+ * @param config - 显隐配置对象
+ * @returns 包含循环依赖的组件组
+ */
+export function detectCircularDependencies(config) {
+  var circularDeps = [];
+  var visiting = new Set();
+  var visited = new Set();
+  function dfs(componentKey) {
+    var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    if (visiting.has(componentKey)) {
+      // 发现循环依赖
+      var cycleStart = path.indexOf(componentKey);
+      circularDeps.push(path.slice(cycleStart).concat(componentKey));
+      return;
+    }
+    if (visited.has(componentKey)) {
+      return;
+    }
+    visiting.add(componentKey);
+    path.push(componentKey);
+    var directDeps = getDirectDependencies(componentKey, config);
+    directDeps.forEach(function (dep) {
+      dfs(dep, _toConsumableArray(path));
+    });
+    visiting.delete(componentKey);
+    visited.add(componentKey);
+  }
+  Object.keys(config).forEach(function (componentKey) {
+    if (!visited.has(componentKey)) {
+      dfs(componentKey);
+    }
+  });
+  return circularDeps;
+}
+
+/**
+ * 打印依赖关系树
+ * @param componentKey - 组件key
+ * @param config - 显隐配置对象
+ * @param level - 缩进级别
+ * @param visited - 已访问的组件集合
+ */
+export function printDependencyTree(componentKey, config) {
+  var level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var visited = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Set();
+  var indent = '  '.repeat(level);
+  console.log("".concat(indent).concat(componentKey));
+  if (visited.has(componentKey)) {
+    console.log("".concat(indent, "  [\u5FAA\u73AF\u4F9D\u8D56]"));
+    return;
+  }
+  visited.add(componentKey);
+  var directDeps = getDirectDependencies(componentKey, config);
+  directDeps.forEach(function (dep) {
+    printDependencyTree(dep, config, level + 1, new Set(visited));
+  });
+}
+
+/**
+ * 获取组件的依赖层级
+ * @param componentKey - 组件key
+ * @param config - 显隐配置对象
+ * @returns 依赖层级对象
+ */
+export function getDependencyLevels(componentKey, config) {
+  var levels = {};
+  var queue = [{
+    key: componentKey,
+    level: 0
+  }];
+  var visited = new Set();
+  var _loop = function _loop() {
+    var current = queue.shift();
+    if (!current) return "break";
+    var key = current.key,
+      level = current.level;
+    if (visited.has(key)) return "continue";
+    visited.add(key);
+    if (level > 0) {
+      // 不包含自己
+      if (!levels[level]) levels[level] = [];
+      levels[level].push(key);
+    }
+    var directDeps = getDirectDependencies(key, config);
+    directDeps.forEach(function (dep) {
+      if (!visited.has(dep)) {
+        queue.push({
+          key: dep,
+          level: level + 1
+        });
+      }
+    });
+  };
+  while (queue.length > 0) {
+    var _ret = _loop();
+    if (_ret === "break") break;
+    if (_ret === "continue") continue;
+  }
+  return levels;
+}
+
+/**
+ * 分析组件的完整依赖信息
+ * @param componentKey - 组件key
+ * @param config - 显隐配置对象
+ * @returns 完整的依赖分析结果
+ */
+export function analyzeDependency(componentKey, config) {
+  var directDependencies = getDirectDependencies(componentKey, config);
+  var allDependencies = findAllDependencies(componentKey, config);
+  var dependencyLevels = getDependencyLevels(componentKey, config);
+
+  // 检查是否有循环依赖
+  var circularDeps = detectCircularDependencies(config);
+  var hasCircularDependency = circularDeps.some(function (cycle) {
+    return cycle.includes(componentKey);
+  });
+  return {
+    componentKey: componentKey,
+    directDependencies: directDependencies,
+    allDependencies: allDependencies,
+    dependencyCount: allDependencies.length,
+    dependencyLevels: dependencyLevels,
+    hasCircularDependency: hasCircularDependency
+  };
+}
+
+/**
+ * 获取依赖统计信息
+ * @param config - 显隐配置对象
+ * @param topN - 返回前N个结果
+ * @returns 组件统计信息数组
+ */
+export function getDependencyStats(config) {
+  var topN = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 10;
+  var dependencyGraph = buildDependencyGraph(config);
+
+  // 统计依赖数量最多的组件
+  var mostDependencies = Object.entries(dependencyGraph).map(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      key = _ref2[0],
+      deps = _ref2[1];
+    return {
+      key: key,
+      count: deps.length
+    };
+  }).sort(function (a, b) {
+    return b.count - a.count;
+  }).slice(0, topN);
+
+  // 统计被依赖最多的组件
+  var dependedOnCount = {};
+  Object.values(dependencyGraph).forEach(function (deps) {
+    deps.forEach(function (dep) {
+      dependedOnCount[dep] = (dependedOnCount[dep] || 0) + 1;
+    });
+  });
+  var mostDependedOn = Object.entries(dependedOnCount).map(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+      key = _ref4[0],
+      count = _ref4[1];
+    return {
+      key: key,
+      count: count
+    };
+  }).sort(function (a, b) {
+    return b.count - a.count;
+  }).slice(0, topN);
+  return {
+    mostDependencies: mostDependencies,
+    mostDependedOn: mostDependedOn
+  };
+}
+
+/**
+ * 验证配置文件格式
+ * @param config - 要验证的配置对象
+ * @returns 验证结果和错误信息
+ */
+export function validateConfig(config) {
+  var errors = [];
+  if (!config || _typeof(config) !== 'object') {
+    errors.push('配置必须是一个对象');
+    return {
+      isValid: false,
+      errors: errors
+    };
+  }
+  var configObj = config;
+  Object.entries(configObj).forEach(function (_ref5) {
+    var _ref6 = _slicedToArray(_ref5, 2),
+      key = _ref6[0],
+      value = _ref6[1];
+    if (!Array.isArray(value)) {
+      errors.push("\u7EC4\u4EF6 ".concat(key, " \u7684\u914D\u7F6E\u5FC5\u987B\u662F\u6570\u7EC4"));
+      return;
+    }
+    value.forEach(function (ruleGroup, index) {
+      if (!ruleGroup || _typeof(ruleGroup) !== 'object') {
+        errors.push("\u7EC4\u4EF6 ".concat(key, " \u7684\u89C4\u5219\u7EC4 ").concat(index, " \u5FC5\u987B\u662F\u5BF9\u8C61"));
+        return;
+      }
+      var group = ruleGroup;
+      if (!group.linkCondition || !['some', 'every'].includes(group.linkCondition)) {
+        errors.push("\u7EC4\u4EF6 ".concat(key, " \u7684\u89C4\u5219\u7EC4 ").concat(index, " linkCondition \u5FC5\u987B\u662F 'some' \u6216 'every'"));
+      }
+      if (!Array.isArray(group.rules)) {
+        errors.push("\u7EC4\u4EF6 ".concat(key, " \u7684\u89C4\u5219\u7EC4 ").concat(index, " rules \u5FC5\u987B\u662F\u6570\u7EC4"));
+      }
+    });
+  });
+  return {
+    isValid: errors.length === 0,
+    errors: errors
+  };
+}