@zid-utils/tree-utils 0.0.6

package/dist/index.js

@@ -0,0 +1,512 @@
+// src/index.ts
+var defaultLogger = {
+  warn: (msg) => console.warn("[tree-utils]", msg),
+  error: (msg) => console.error("[tree-utils]", msg)
+};
+var getLeafNodes = (treeData, isLeafKey = "isLeaf") => {
+  function collectLeafNodes(nodes) {
+    const leafNodes = [];
+    for (const node of nodes) {
+      if (node[isLeafKey] === true) {
+        leafNodes.push(node);
+      } else if (node.children) {
+        leafNodes.push(...collectLeafNodes(node.children));
+      }
+    }
+    return leafNodes;
+  }
+  return collectLeafNodes(treeData);
+};
+var filterTreeNodes = (nodes, callback, isOnlyFilterChildren = true) => {
+  const filterChildren = (children) => {
+    if (children && children.length > 0) {
+      return children.filter(callback).map((child) => {
+        return {
+          ...child,
+          children: filterChildren(child.children)
+        };
+      });
+    }
+    return [];
+  };
+  const rootNodes = isOnlyFilterChildren ? nodes : nodes.filter(callback);
+  return rootNodes.map((node) => ({
+    ...node,
+    children: filterChildren(node.children)
+  }));
+};
+var findNodeByKey = (treeData, key) => {
+  for (let i = 0; i < treeData.length; i++) {
+    const node = treeData[i];
+    if (node.key === key) {
+      return node;
+    }
+    if (node.children) {
+      const foundNode = findNodeByKey(node.children, key);
+      if (foundNode) {
+        return foundNode;
+      }
+    }
+  }
+  return null;
+};
+var searchInTree = (tree, searchValue) => {
+  function searchRecursive(node, searchText, result2) {
+    const title = node.title?.toString().toLowerCase() || "";
+    const text = searchText.toLowerCase();
+    const arr = text.split("");
+    if (node.isLeaf && arr.every((item) => title.includes(item))) {
+      if (!result2.some((item) => item.key === node.key)) {
+        result2.push(node);
+      }
+    }
+    if (node.children) {
+      for (const child of node.children) {
+        searchRecursive(child, text, result2);
+      }
+    }
+  }
+  const result = [];
+  for (const rootNode of tree) {
+    searchRecursive(rootNode, searchValue.toLowerCase(), result);
+  }
+  return result;
+};
+var updateKeys = (sourceNode, targetNode) => {
+  sourceNode.key = `${targetNode.key}-${targetNode.children?.length}`;
+  if (sourceNode.children) {
+    sourceNode.children.forEach((item, index) => {
+      item.key = `${sourceNode.key}-${index}`;
+    });
+  }
+};
+var moveNodeInTree = (treeData, sourceKey, targetKey, logger = defaultLogger) => {
+  function findNode(nodes, key) {
+    if (!nodes) return null;
+    for (const node of nodes) {
+      if (node.key === key) return node;
+      if (node.children) {
+        const found = findNode(node.children, key);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  function getParentNode(nodes, node) {
+    for (const parent of nodes) {
+      if (parent.children && parent.children.includes(node)) {
+        return parent;
+      }
+      const result = getParentNode(parent.children || [], node);
+      if (result) return result;
+    }
+    return null;
+  }
+  const sourceNode = findNode(
+    Array.isArray(treeData) ? treeData : [treeData],
+    sourceKey
+  );
+  const targetNode = findNode(
+    Array.isArray(treeData) ? treeData : [treeData],
+    targetKey
+  );
+  if (!sourceNode || !targetNode) {
+    logger.error?.("Source or target node not found");
+    return;
+  }
+  if (sourceNode.children && sourceNode.children.length > 0) {
+    logger.error?.("Source node is not a leaf node, cannot move");
+    return;
+  }
+  const sourceParent = getParentNode(
+    Array.isArray(treeData) ? treeData : [treeData],
+    sourceNode
+  );
+  if (sourceParent) {
+    const index = sourceParent.children.findIndex(
+      (child) => child.key === sourceKey
+    );
+    if (index !== -1) {
+      sourceParent.children.splice(index, 1);
+    }
+  }
+  targetNode.children = targetNode.children || [];
+  targetNode.children.push(sourceNode);
+};
+var cloneNode = (sourceNode, targetNode) => {
+  const clonedNode = { ...sourceNode };
+  if (targetNode.children) {
+    targetNode.children.push(clonedNode);
+  } else {
+    targetNode.children = [clonedNode];
+  }
+};
+var copyNode = (treeData, key, targetKey) => {
+  const sourceNode = structuredClone(findNodeByKey(treeData, key));
+  const targetNode = findNodeByKey(treeData, targetKey);
+  if (sourceNode && targetNode) {
+    sourceNode.title += "-\u526F\u672C";
+    updateKeys(sourceNode, targetNode);
+    cloneNode(sourceNode, targetNode);
+    return [...treeData];
+  }
+  return treeData;
+};
+var updateNodeTitleByKey = (tree, targetKey, newTitle) => {
+  for (const node of tree) {
+    if (node.key === targetKey) {
+      node.title = newTitle;
+      return;
+    }
+    if (node.children) {
+      updateNodeTitleByKey(node.children, targetKey, newTitle);
+    }
+  }
+};
+var deleteNode = (treeData, key) => {
+  const delNode = (data) => {
+    return data.filter((node) => {
+      if (node.key === key) {
+        return false;
+      }
+      if (node.children) {
+        node.children = delNode(node.children);
+      }
+      return true;
+    });
+  };
+  return delNode([...treeData]);
+};
+var flattenTree = (tree, filter = () => true) => {
+  const result = [];
+  const flatten = (node) => {
+    if (filter(node)) {
+      result.push(node);
+    }
+    if (node.children) {
+      node.children.forEach(flatten);
+    }
+  };
+  tree.forEach(flatten);
+  return result;
+};
+var addLeafProperties = (treeData) => {
+  return treeData.map((node) => {
+    const isLeaf = !node.children || node.children.length === 0;
+    return {
+      ...node,
+      isLeaf,
+      disabled: !isLeaf,
+      children: node.children ? addLeafProperties(node.children) : void 0
+    };
+  });
+};
+var findNodeById = (nodes, id) => {
+  for (const node of nodes) {
+    if (node.id === id) return node;
+    if (node.children && node.children.length) {
+      const found = findNodeById(node.children, id);
+      if (found) return found;
+    }
+  }
+  return null;
+};
+var filterCheckedLeafKeys = (treeData) => {
+  const result = [];
+  const traverse = (nodes) => {
+    if (!nodes || nodes.length === 0) return;
+    for (const node of nodes) {
+      if (node.checked === false) continue;
+      if (node.children && node.children.length > 0) {
+        traverse(node.children);
+      } else if (node.checked === true) {
+        result.push(node.key);
+      }
+    }
+  };
+  traverse(treeData);
+  return result;
+};
+var nodeExistsInTree = (nodes, searchValue) => {
+  return nodes.some((node) => {
+    if (node.value === searchValue || node.title === searchValue) {
+      return true;
+    }
+    if (node.children && Array.isArray(node.children)) {
+      return nodeExistsInTree(node.children, searchValue);
+    }
+    return false;
+  });
+};
+var collectLeafValuesByKey = (nodes, targetValue, isLeafKey = "isLeaf") => {
+  for (const node of nodes) {
+    if (node.value === targetValue) {
+      if (node.children && Array.isArray(node.children) && node.children.length > 0) {
+        const leafNodes = getLeafNodes([node], isLeafKey);
+        return leafNodes.map((leaf) => leaf.value);
+      }
+      return null;
+    }
+    if (node.children && Array.isArray(node.children)) {
+      const result = collectLeafValuesByKey(
+        node.children,
+        targetValue,
+        isLeafKey
+      );
+      if (result !== null) {
+        return result;
+      }
+    }
+  }
+  return null;
+};
+var transformTreeKeys = (treeData, keyMapping, childrenKey = "children", logger = defaultLogger) => {
+  if (!Array.isArray(treeData)) {
+    logger.warn?.("transformTreeKeys: treeData must be an array");
+    return [];
+  }
+  const transformNode = (node) => {
+    if (!node || typeof node !== "object") {
+      return node;
+    }
+    const transformedNode = {};
+    Object.keys(node).forEach((key) => {
+      const value = node[key];
+      const newKey = keyMapping[key] || key;
+      if (key === childrenKey && Array.isArray(value)) {
+        transformedNode[newKey] = transformTreeKeys(
+          value,
+          keyMapping,
+          childrenKey,
+          logger
+        );
+      } else {
+        transformedNode[newKey] = value;
+      }
+    });
+    return transformedNode;
+  };
+  return treeData.map(transformNode);
+};
+var transformTreeNodes = (treeData, transformer, childrenKey = "children", logger = defaultLogger) => {
+  if (!Array.isArray(treeData)) {
+    logger.warn?.("transformTreeNodes: treeData must be an array");
+    return [];
+  }
+  const transformNode = (node) => {
+    if (!node || typeof node !== "object") {
+      return node;
+    }
+    const children = node[childrenKey];
+    const nodeWithTransformedChildren = {
+      ...node,
+      ...Array.isArray(children) && {
+        [childrenKey]: transformTreeNodes(
+          children,
+          transformer,
+          childrenKey,
+          logger
+        )
+      }
+    };
+    return transformer(nodeWithTransformedChildren);
+  };
+  return treeData.map(transformNode);
+};
+var findParentOf = (nodes, targetKey) => {
+  for (const node of nodes) {
+    if (node.children?.some((child) => child.key === targetKey)) {
+      return node;
+    }
+    if (node.children) {
+      const found = findParentOf(node.children, targetKey);
+      if (found) return found;
+    }
+  }
+  return null;
+};
+var findNodeByMatcher = (nodes, matcher, childrenKey = "children") => {
+  for (const node of nodes) {
+    if (matcher(node)) {
+      return node;
+    }
+    if (node[childrenKey]) {
+      const found = findNodeByMatcher(node[childrenKey], matcher, childrenKey);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+};
+var updateNodeByMatcher = (nodes, matcher, updater, childrenKey = "children") => {
+  return nodes.map((node) => {
+    if (matcher(node)) {
+      return updater(node);
+    }
+    if (node[childrenKey] && node[childrenKey].length > 0) {
+      const newChildren = updateNodeByMatcher(
+        node[childrenKey],
+        matcher,
+        updater,
+        childrenKey
+      );
+      if (newChildren !== node[childrenKey]) {
+        return {
+          ...node,
+          [childrenKey]: newChildren
+        };
+      }
+    }
+    return node;
+  });
+};
+var getNodePath = (treeData, targetKey, keyField = "key", childrenKey = "children") => {
+  const findPath = (nodes, target, currentPath) => {
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      const newPathNode = {
+        node,
+        depth: currentPath.length,
+        index: i,
+        parent: currentPath.length > 0 ? currentPath[currentPath.length - 1] : null,
+        path: currentPath.length === 0 ? String(node[keyField]) : `${currentPath[currentPath.length - 1].path}/${String(node[keyField])}`
+      };
+      if (node[keyField] === target) {
+        return [...currentPath, newPathNode];
+      }
+      const children = node[childrenKey];
+      if (children && Array.isArray(children) && children.length > 0) {
+        const result = findPath(children, target, [
+          ...currentPath,
+          newPathNode
+        ]);
+        if (result) {
+          return result;
+        }
+      }
+    }
+    return null;
+  };
+  return findPath(treeData, targetKey, []);
+};
+var getNodeDepth = (treeData, targetKey, keyField = "key", childrenKey = "children") => {
+  const path = getNodePath(treeData, targetKey, keyField, childrenKey);
+  return path ? path.length - 1 : -1;
+};
+var getNodeBreadcrumb = (treeData, targetKey, keyField = "key", childrenKey = "children") => {
+  const path = getNodePath(treeData, targetKey, keyField, childrenKey);
+  return path ? path.map((p) => p.node) : [];
+};
+var getTreeStats = (treeData, childrenKey = "children") => {
+  let totalNodes = 0;
+  let maxDepth = 0;
+  let leafCount = 0;
+  const traverse = (nodes, depth) => {
+    for (const node of nodes) {
+      totalNodes++;
+      maxDepth = Math.max(maxDepth, depth);
+      const children = node[childrenKey];
+      if (children && Array.isArray(children) && children.length > 0) {
+        traverse(children, depth + 1);
+      } else {
+        leafCount++;
+      }
+    }
+  };
+  traverse(treeData, 0);
+  return { totalNodes, maxDepth, leafCount };
+};
+var mapTree = (treeData, mapper, childrenKey = "children") => {
+  const traverse = (nodes, parent) => {
+    return nodes.map((node) => {
+      const mappedNode = mapper(node, parent);
+      const children = node[childrenKey];
+      if (children && Array.isArray(children) && children.length > 0) {
+        return {
+          ...mappedNode,
+          [childrenKey]: traverse(children, node)
+        };
+      }
+      return mappedNode;
+    });
+  };
+  return traverse(treeData);
+};
+var findFirstLeaf = (treeData, childrenKey = "children") => {
+  for (const node of treeData) {
+    const children = node[childrenKey];
+    if (!children || children.length === 0) {
+      return node;
+    }
+    const leaf = findFirstLeaf(children, childrenKey);
+    if (leaf) return leaf;
+  }
+  return null;
+};
+var traverseTreeValues = (treeData, key, childrenKey = "children") => {
+  const result = [];
+  const traverse = (nodes) => {
+    for (const node of nodes) {
+      if (key in node) {
+        result.push(node[key]);
+      }
+      const children = node[childrenKey];
+      if (children && Array.isArray(children) && children.length > 0) {
+        traverse(children);
+      }
+    }
+  };
+  traverse(treeData);
+  return result;
+};
+var convertGroupsToTreeData = (groups, groupKey = "group", _childrenKey = "children") => {
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const item of groups) {
+    const groupName = String(item[groupKey] || "");
+    if (!groupMap.has(groupName)) {
+      groupMap.set(groupName, {
+        label: groupName,
+        value: groupName,
+        children: []
+      });
+    }
+    groupMap.get(groupName).children.push(item);
+  }
+  return Array.from(groupMap.values());
+};
+export {
+  addLeafProperties,
+  cloneNode,
+  collectLeafValuesByKey,
+  convertGroupsToTreeData,
+  copyNode,
+  deleteNode,
+  filterCheckedLeafKeys,
+  filterTreeNodes,
+  findFirstLeaf,
+  findNodeById as findNode,
+  collectLeafValuesByKey as findNodeAndCollectLeafValues,
+  findNodeById,
+  findNodeByKey,
+  findNodeByMatcher,
+  nodeExistsInTree as findNodeInTree,
+  findParentOf,
+  findParentOf as findTreeNode,
+  flattenTree,
+  getLeafNodes,
+  getNodeBreadcrumb,
+  getNodeDepth,
+  getNodePath,
+  getTreeStats,
+  mapTree,
+  moveNodeInTree,
+  nodeExistsInTree,
+  searchInTree,
+  transformTreeKeys,
+  transformTreeNodes,
+  traverseTreeValues,
+  updateKeys,
+  updateNodeByMatcher,
+  updateNodeTitleByKey
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@zid-utils/tree-utils",
+  "version": "0.0.6",
+  "description": "Tree data structure utility functions",
+  "repository": "github:huangzida/utils-packages",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "tsup": "^8.0.2",
+    "vitest": "^2.0.0",
+    "typescript": "^5.4.5"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --out-dir dist --clean",
+    "test": "vitest run"
+  }
+}