@shencom/utils-tree/dist/index.js

树形数据结构相关工具方法

import { cloneDeep } from 'lodash-es';

function ToArray(val) {
  val = val != null ? val : [];
  return Array.isArray(val) ? val : [val];
}

var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
function TreeToArray(tree, options) {
  const { keepChildren = false, children = "children" } = options || {};
  const data = ToArray(tree);
  const flattenedData = [];
  function traverse(nodes) {
    nodes.forEach((node) => {
      const item = node ? __spreadValues({}, node) : node;
      if (node) {
        if (!keepChildren)
          delete item[children];
        if (node[children]) {
          traverse(node[children]);
        }
      }
      flattenedData.push(item);
    });
  }
  traverse(data);
  return flattenedData;
}
function TreeFindNode(tree, id, maps) {
  const map_id = (maps == null ? void 0 : maps.id) || "id";
  const map_children = (maps == null ? void 0 : maps.children) || "children";
  function traverse(nodes) {
    var _a;
    for (let i = 0; i < nodes.length; i++) {
      const node = nodes[i];
      if (!node)
        break;
      if (node[map_id] === id) {
        return node;
      }
      if ((_a = node[map_children]) == null ? void 0 : _a.length) {
        const result = traverse(node[map_children]);
        if (result)
          return result;
      }
    }
    return null;
  }
  const res = traverse(ToArray(tree));
  return res;
}
function TreeFindParentNodes(tree, id, maps, keepChildren = false) {
  const mapKey = {
    children: (maps == null ? void 0 : maps.children) || "children",
    id: (maps == null ? void 0 : maps.id) || "id",
    pid: (maps == null ? void 0 : maps.pid) || "pid"
  };
  const result = [];
  const process = TreeToArray(tree, { children: mapKey.children, keepChildren });
  function findParent(_id) {
    const node = process.find((item) => item[mapKey.id] === _id);
    if (node) {
      result.unshift(node);
      if (node[mapKey.pid])
        findParent(node[mapKey.pid]);
    }
  }
  findParent(id);
  return result;
}
function TreeFindParentIds(tree, id, maps) {
  const mapKey = {
    children: (maps == null ? void 0 : maps.children) || "children",
    id: (maps == null ? void 0 : maps.id) || "id",
    pid: (maps == null ? void 0 : maps.pid) || "pid"
  };
  const nodes = TreeFindParentNodes(tree, id, mapKey);
  return nodes.map((item) => item[mapKey.id]);
}
function TreeFindParentByKey(tree, props, keepChildren) {
  const { key, value, id = "id", pid = "pid", children = "children" } = props;
  const nodes = TreeToArray(tree, {
    children,
    keepChildren
  });
  const node = nodes.find((item) => item[key] === value);
  if (!node)
    return [];
  const result = [node];
  let parent_id = node == null ? void 0 : node[pid];
  while (parent_id !== void 0) {
    const parent = nodes.find((item) => item[id] === parent_id);
    parent_id = parent == null ? void 0 : parent[pid];
    if (parent) {
      if (!keepChildren)
        delete parent[children];
      result.unshift(parent);
    }
  }
  return result;
}
function TreeMap(tree, handler, maps) {
  const { children = "children" } = maps || {};
  tree = cloneDeep(tree);
  function processTree(nodes2) {
    var _a;
    const modifiedArray = [];
    for (let i = 0; i < nodes2.length; i++) {
      let item = nodes2[i];
      if (item && ((_a = item[children]) == null ? void 0 : _a.length)) {
        item[children] = processTree(item[children]);
      }
      item = handler(cloneDeep(item));
      modifiedArray.push(item);
    }
    return modifiedArray;
  }
  const nodes = processTree(ToArray(tree));
  if (Array.isArray(tree)) {
    return nodes;
  }
  return nodes[0];
}
function TreeForEach(tree, handler, maps) {
  TreeMap(
    tree,
    (node) => {
      handler(cloneDeep(node));
      return node;
    },
    maps
  );
}
const TreeMapOption = (tree, maps, childKey) => {
  const nodes = TreeMap(
    tree,
    (node) => {
      const item = node;
      if (maps && Object.keys(maps).length) {
        Object.entries(maps).forEach(([k, v]) => {
          item[v] = item[k];
          delete item[k];
        });
      }
      return item;
    },
    { children: childKey || "children" }
  );
  return nodes;
};
function TreeFilter(tree, condition, maps) {
  if (!tree)
    return null;
  const nodes = cloneDeep(Array.isArray(tree) ? tree[0] : tree);
  function handler(node) {
    var _a, _b;
    const { children = "children" } = maps || {};
    const filteredChildren = [];
    if ((_a = node[children]) == null ? void 0 : _a.length) {
      for (const child of node[children]) {
        const filteredChild = handler(child);
        if (filteredChild) {
          filteredChildren.push(filteredChild);
        }
      }
    }
    const newRoot = __spreadProps(__spreadValues({}, node), { [children]: filteredChildren });
    if (condition(newRoot) || ((_b = newRoot[children]) == null ? void 0 : _b.length)) {
      return newRoot;
    }
    return null;
  }
  const res = handler(nodes);
  if (Array.isArray(tree)) {
    return res ? [res] : null;
  }
  return res;
}
function TreeFilterChildEmpty(tree, maps) {
  const { children = "children" } = maps || {};
  const nodes = ToArray(cloneDeep(tree));
  function deleteEmptyChildren(arr) {
    arr == null ? void 0 : arr.forEach((node) => {
      var _a;
      if (Object.prototype.hasOwnProperty.call(node, children)) {
        if (((_a = node[children]) == null ? void 0 : _a.length) > 0)
          deleteEmptyChildren(node[children]);
        else
          delete node[children];
      }
    });
  }
  deleteEmptyChildren(nodes);
  if (Array.isArray(tree)) {
    return nodes;
  }
  return nodes[0];
}

export { TreeFilter, TreeFilterChildEmpty, TreeFindNode, TreeFindParentByKey, TreeFindParentIds, TreeFindParentNodes, TreeForEach, TreeMap, TreeMapOption, TreeToArray };
//# sourceMappingURL=index.js.map