SkylerHu / antd-restful / #3

Committed 10 Jul 2025 02:38PM UTC coverage: 77.983%. First build

Build # #3

Build Type

push

Committed by

Commit Message

feat: 扩展组件支持远程获取数据 (#1)

扩展组件支持远程获取数据

Run Details

1016 of 1392 branches covered (72.99%)

Branch coverage included in aggregate %.

1352 of 1644 new or added lines in 28 files covered. (82.24%)

1389 of 1692 relevant lines covered (82.09%)

26.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.04

/src/common/treeUtils.js

import { commonFormat } from "./parser";
import { isArray, isBlank, isEmpty, isNull } from "./typeTools";

/**
 * 更具设置更新tredData中属性值
 * @param {Array} treeData 树结构数据
 * @param {Object} options 选项
 * @param {string} options.fieldKey 字段key,会作为tree结点唯一值
 * @param {string} options.labelTemplate label模板
 * @param {boolean} options.isLoadAll treeData是否是加载的全部结点
 */
export const patchTreeNodeInfo = (
  treeData,
  { fieldKey = "key", fieldChildren = "children", labelTemplate, isLoadAll = false }
) => {
  for (let i = 0; i < treeData.length; i++) {
    const node = treeData[i];
    if (node[fieldKey] === undefined) {
      // 补充必须的key字段
      node.key = node[fieldKey];
    }
    if (labelTemplate) {
      // 格式化label
      node.label = commonFormat(labelTemplate, node);
    }
    // 判断是否叶子结点
    if (!isBlank(node.isLeaf)) {
      // 数据中已有的不做处理
    } else if (isLoadAll && isNull(node[fieldChildren])) {
      // 加载全部结点后，若无子结点，则认为是叶子结点
      node.isLeaf = true;
    }
    if (isArray(node[fieldChildren])) {
      patchTreeNodeInfo(node[fieldChildren], { fieldKey, fieldChildren, labelTemplate, isLoadAll });
    }
  }
};

/**
 * 从数结构数据中，根据parentKey找到对应结点
 */
export const findNodeByKey = (treeData, nodeKey, { fieldKey = "key", fieldChildren = "children" }) => {
  if (isEmpty(nodeKey) || isEmpty(treeData)) {
    return null;
  }

  // 递归查找父类结点
  for (let i = 0; i < treeData.length; i++) {
    const node = treeData[i];
    const value = node[fieldKey];
    if (nodeKey && value === nodeKey) {
      return node;
    }
    if (nodeKey && !isEmpty(node[fieldChildren])) {
      return findNodeByKey(node[fieldChildren], nodeKey, { fieldKey, fieldChildren });
    }
  }
  return null;
};

export const findNodesByKeys = (treeData, nodeKeys, { fieldKey = "key", fieldChildren = "children" }) => {
  if (isEmpty(nodeKeys) || isEmpty(treeData)) {
    return [];
  }
  if (!isArray(nodeKeys)) {
    // 转换为数组
    nodeKeys = [nodeKeys];
  }

  let nodes = [];
  // 递归查找父类结点
  for (let i = 0; i < treeData.length; i++) {
    const node = treeData[i];
    const value = node[fieldKey];
    if (nodeKeys.includes(value)) {
      nodes.push(node);
    }
    if (!isEmpty(node[fieldChildren])) {
      nodes = nodes.concat(...findNodesByKeys(node[fieldChildren], nodeKeys, { fieldKey, fieldChildren }));
    }
  }
  return nodes;
};

export const refreshTreeKeyMap = (treeData, { fieldKey = "key", fieldChildren = "children" }) => {
  let mapData = {};
  for (let i = 0; i < treeData.length; i++) {
    const node = treeData[i];
    mapData[node[fieldKey]] = node;
    if (!isEmpty(node[fieldChildren])) {
      const _data = refreshTreeKeyMap(node[fieldChildren], { fieldKey, fieldChildren });
      mapData = { ...mapData, ..._data };
    }
  }
  return mapData;
};

/**
 * 向树结构数据treeData中，将nodes插入作为某结点的children
 */
export const insertChildrenToTreeNode = (treeData, nodes, parentKey, { fieldKey = "key", fieldChildren = "children" }) => {
  // 无任何子结点
  if (isEmpty(nodes)) {
    return treeData;
  }
  // 若是刷新根结点
  if (!parentKey) {
    return nodes;
  }
  if (isEmpty(treeData)) {
    return nodes;
  }
  // 递归查找父类结点
  const parentNode = findNodeByKey(treeData, parentKey, { fieldKey, fieldChildren });
  // 未找到结果不做处理
  if (!parentNode) {
    return treeData;
  }
  parentNode[fieldChildren] = nodes;
  return treeData;
};

1	import { commonFormat } from "./parser";
2	import { isArray, isBlank, isEmpty, isNull } from "./typeTools";
3
4	/**
5	* 更具设置更新tredData中属性值
6	* @param {Array} treeData 树结构数据
7	* @param {Object} options 选项
8	* @param {string} options.fieldKey 字段key,会作为tree结点唯一值
9	* @param {string} options.labelTemplate label模板
10	* @param {boolean} options.isLoadAll treeData是否是加载的全部结点
11	*/
12	export const patchTreeNodeInfo = (	4✔
13	treeData,
14	{ fieldKey = "key", fieldChildren = "children", labelTemplate, isLoadAll = false }	10!
15	) => {
16	for (let i = 0; i < treeData.length; i++) {	15✔
17	const node = treeData[i];	21✔
18	if (node[fieldKey] === undefined) {	21!
19	// 补充必须的key字段
NEW 20	node.key = node[fieldKey];	×
21	}
22	if (labelTemplate) {	21✔
23	// 格式化label
24	node.label = commonFormat(labelTemplate, node);	6✔
25	}
26	// 判断是否叶子结点
27	if (!isBlank(node.isLeaf)) {	21✔
28	// 数据中已有的不做处理
29	} else if (isLoadAll && isNull(node[fieldChildren])) {	16✔
30	// 加载全部结点后，若无子结点，则认为是叶子结点
31	node.isLeaf = true;	1✔
32	}
33	if (isArray(node[fieldChildren])) {	21✔
34	patchTreeNodeInfo(node[fieldChildren], { fieldKey, fieldChildren, labelTemplate, isLoadAll });	8✔
35	}
36	}
37	};
38
39	/**
40	* 从数结构数据中，根据parentKey找到对应结点
41	*/
42	export const findNodeByKey = (treeData, nodeKey, { fieldKey = "key", fieldChildren = "children" }) => {	4!
43	if (isEmpty(nodeKey) \|\| isEmpty(treeData)) {	18✔
44	return null;	2✔
45	}
46
47	// 递归查找父类结点
48	for (let i = 0; i < treeData.length; i++) {	16✔
49	const node = treeData[i];	16✔
50	const value = node[fieldKey];	16✔
51	if (nodeKey && value === nodeKey) {	16✔
52	return node;	6✔
53	}
54	if (nodeKey && !isEmpty(node[fieldChildren])) {	10✔
55	return findNodeByKey(node[fieldChildren], nodeKey, { fieldKey, fieldChildren });	8✔
56	}
57	}
58	return null;	2✔
59	};
60
61	export const findNodesByKeys = (treeData, nodeKeys, { fieldKey = "key", fieldChildren = "children" }) => {	4!
62	if (isEmpty(nodeKeys) \|\| isEmpty(treeData)) {	18✔
63	return [];	2✔
64	}
65	if (!isArray(nodeKeys)) {	16✔
66	// 转换为数组
67	nodeKeys = [nodeKeys];	1✔
68	}
69
70	let nodes = [];	16✔
71	// 递归查找父类结点
72	for (let i = 0; i < treeData.length; i++) {	16✔
73	const node = treeData[i];	24✔
74	const value = node[fieldKey];	24✔
75	if (nodeKeys.includes(value)) {	24✔
76	nodes.push(node);	6✔
77	}
78	if (!isEmpty(node[fieldChildren])) {	24✔
79	nodes = nodes.concat(...findNodesByKeys(node[fieldChildren], nodeKeys, { fieldKey, fieldChildren }));	12✔
80	}
81	}
82	return nodes;	16✔
83	};
84
85	export const refreshTreeKeyMap = (treeData, { fieldKey = "key", fieldChildren = "children" }) => {	4!
86	let mapData = {};	15✔
87	for (let i = 0; i < treeData.length; i++) {	15✔
88	const node = treeData[i];	18✔
89	mapData[node[fieldKey]] = node;	18✔
90	if (!isEmpty(node[fieldChildren])) {	18✔
91	const _data = refreshTreeKeyMap(node[fieldChildren], { fieldKey, fieldChildren });	7✔
92	mapData = { ...mapData, ..._data };	7✔
93	}
94	}
95	return mapData;	15✔
96	};
97
98	/**
99	* 向树结构数据treeData中，将nodes插入作为某结点的children
100	*/
101	export const insertChildrenToTreeNode = (treeData, nodes, parentKey, { fieldKey = "key", fieldChildren = "children" }) => {	4!
102	// 无任何子结点
103	if (isEmpty(nodes)) {	7✔
104	return treeData;	2✔
105	}
106	// 若是刷新根结点
107	if (!parentKey) {	5✔
108	return nodes;	2✔
109	}
110	if (isEmpty(treeData)) {	3!
NEW 111	return nodes;	×
112	}
113	// 递归查找父类结点
114	const parentNode = findNodeByKey(treeData, parentKey, { fieldKey, fieldChildren });	3✔
115	// 未找到结果不做处理
116	if (!parentNode) {	3✔
117	return treeData;	1✔
118	}
119	parentNode[fieldChildren] = nodes;	2✔
120	return treeData;	2✔
121	};

SkylerHu / antd-restful / #3

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous