dlsjs 0.1.23 → 0.1.24

package/package.json

@@ -3,7 +3,7 @@
   "author": "林川",
   "license": "MIT",
   "private": false,
-  "version": "0.1.23",
+  "version": "0.1.24",
   "description": "domain-language for js",
   "main": "dist/dlsjs.esm.js",
   "module": "dist/dlsjs.esm.js",

package/src/core/ES/Tree.js

@@ -6,26 +6,65 @@
 import {isType} from "./Judgment";
 import {clone, uniqBy} from "ramda";
 
+/**
+ * 列表转树（高性能版，适配100W+数据）
+ * @param {Array} list - 原始列表数据
+ * @param {Object} extendProps - 自定义属性映射 {id: 'id', children: 'children', parentId: 'parentId'}
+ * @returns {Array} 树形结构数据
+ */
 export function list2Tree (list, extendProps = {}) {
-    let props = {id: 'id', children: 'children', parentId: 'parentId', useConcat: false};
-    Object.assign(props,extendProps)
-    list.forEach((parent) => {
-        parent.tempChildren = list.filter(child => child[props.parentId] === parent[props.id] && parent[props.id] && child[props.parentId])
-        parent.tempChildren.forEach(item => {item._hasParent = true})
-        if(parent[props.children] && props.useConcat) parent[props.children] = parent[props.children].concat(parent.tempChildren)
-        else {
-            parent[props.children] = parent.tempChildren
-            delete parent.tempChildren
+    // 1. 配置默认属性映射，兼容自定义字段
+    const props = {
+        id: 'id',
+        children: 'children',
+        parentId: 'parentId',
+        useConcat: false, // 保留原有配置，实际优化后无需concat
+        ...extendProps
+    };
+
+    const { id: idKey, children: childrenKey, parentId: parentIdKey, useConcat } = props;
+
+    // 2. 构建ID到节点的哈希映射（O(n)），同时初始化children数组
+    const nodeMap = new Map();
+    const rootNodes = []; // 存储根节点（parentId为空/0/不存在的节点）
+
+    // 第一次遍历：初始化映射和children，O(n)
+    for (const node of list) {
+        const nodeId = node[idKey];
+        // 初始化children数组（避免后续判断undefined）
+        if (!node[childrenKey]) {
+            node[childrenKey] = [];
         }
-    })
-    let result = list.filter(item => !item._hasParent)
-    list.forEach(item => {
-        delete item._hasParent
-        if(item.children && item.children.length === 0) {
-            delete item.children
+        // 将节点存入Map，方便后续快速查找父节点
+        nodeMap.set(nodeId, node);
+    }
+
+    // 第二次遍历：关联父子节点，O(n)
+    for (const node of list) {
+        const parentId = node[parentIdKey];
+        const parentNode = nodeMap.get(parentId);
+
+        if (parentNode) {
+            // 有父节点：添加到父节点的children中
+            if (useConcat && Array.isArray(parentNode[childrenKey])) {
+                parentNode[childrenKey] = parentNode[childrenKey].concat(node);
+            } else {
+                parentNode[childrenKey].push(node);
+            }
+        } else {
+            // 无父节点：归为根节点（parentId为空/0/不存在）
+            rootNodes.push(node);
         }
-    })
-    return result
+    }
+
+    // 3. 清理空children（可选，保持和原逻辑一致）
+    for (const node of list) {
+        if (Array.isArray(node[childrenKey]) && node[childrenKey].length === 0) {
+            delete node[childrenKey];
+        }
+    }
+
+    return rootNodes;
 }
 
 /**
@@ -170,6 +209,11 @@ export function forkProp(obj, leafKey, propName) {
  * @param dimMap 维表关联映射字段 e.g.{'市': {propFieldName: 'code1', textFieldName: 'name1'}, '区': {propFieldName: 'code2', textFieldName: 'name2'}, '乡镇': {propFieldName: 'code3', textFieldName: 'name3'}}
  */
 export function dim2Tree(dimList, dimLink, dimMap) {
+    let list = dim2List(dimList, dimLink, dimMap)
+    return list2Tree(list);
+}
+
+export function dim2List(dimList, dimLink, dimMap) {
     let filedSort = [];
     if (dimLink.length) {
         for (let propName of dimLink) {
@@ -193,8 +237,7 @@ export function dim2Tree(dimList, dimLink, dimMap) {
             dataTreeOrg.push(node);
         }
     }
-    dataTreeOrg = uniqBy(item => item.id, dataTreeOrg);
-    return list2Tree(dataTreeOrg);
+    return uniqBy(item => item.id, dataTreeOrg);
 }
 
 /**
@@ -233,19 +276,58 @@ export function tree2List(treeLike, list = []) {
     return list
 }
 
+/**
+ * 裁剪树形结构到指定层级（高性能版，不裁剪原始树，返回一颗新树）
+ * @param {Array} treeLike - 原始树形结构数据
+ * @param {number} level - 要保留的层级（从1开始，level=1保留根节点，level=2保留根+一级子节点，以此类推）
+ * @returns {Array} 裁剪后的指定层级节点列表
+ */
 export function treeCutLevel(treeLike, level) {
-    let list = clone(treeLike)
-    let target = []
-    for(let i = 1; i <= level; i++) {
-        if(i === level) {
-            target.forEach(item => delete item.children)
-        }else {
-            target = list.map(item => item.children).flat()
+    // 边界值处理：层级≤0 返回空，层级=1 直接返回根节点（浅拷贝避免修改原数据）
+    if (level <= 0) return [];
+    if (level === 1) {
+        // 只保留根节点，浅拷贝根节点（删除children），不影响原数据
+        return treeLike.map(node => {
+            const newNode = { ...node }; // 浅拷贝当前节点
+            delete newNode.children;     // 移除子节点，只保留当前层级
+            return newNode;
+        });
+    }
+
+    // 初始化：当前处理的层级节点列表（初始为根节点）
+    let currentLevelNodes = [...treeLike]; // 浅拷贝当前层级节点，不修改原数组
+    // 存储最终要返回的目标层级节点
+    let targetNodes = [];
+
+    // 遍历到指定层级（从第2层开始，到level层结束）
+    for (let currentLevel = 2; currentLevel <= level; currentLevel++) {
+        // 收集下一层的所有节点
+        const nextLevelNodes = [];
+
+        for (const node of currentLevelNodes) {
+            // 只处理有children的节点
+            if (node.children && node.children.length > 0) {
+                if (currentLevel === level) {
+                    // 到达目标层级：浅拷贝当前子节点，删除其children后加入结果
+                    const cutNodes = node.children.map(child => {
+                        const newChild = { ...child };
+                        delete newChild.children;
+                        return newChild;
+                    });
+                    targetNodes.push(...cutNodes);
+                } else {
+                    // 未到目标层级：收集子节点，继续遍历下一层
+                    nextLevelNodes.push(...node.children);
+                }
+            }
         }
+
+        // 更新当前层级节点为下一层
+        currentLevelNodes = nextLevelNodes;
+
+        // 提前终止：如果下一层没有节点，无需继续循环
+        if (currentLevelNodes.length === 0) break;
     }
-    return target
-}
 
-export default {
-    list2Tree, setParentIds4List, treeFind, treeDel, treeMap, treeFindParent, findLeaf, treeCutLevel
+    return targetNodes;
 }