operation-tree-node
    TypeScript icon, indicating that this package has built-in type declarations

    1.0.9 • Public • Published

    Operation method collection for tree node(like operation array).

    Usage

    • Install
    npm install --save operation-tree-node
    

    Methods

    common arguments:

    name type description
    data object[] example: [{ id: 1, name: "1", children: [{ id: 2, name: "2" }] }]
    callback (node, index, arr, parent) => boolean/object/void node: tree node, index: parent children's index,
    arr: parent children, parent: parent node
    props { id: string, children: string, parent: string } tree node's 'children', 'parent' and 'id' key name

    examples:

    • treeCheck(data, checkIds, props) tree node check

    get all associated node'id by check one node.

    arguments:

    name type description
    data (same) (same)
    checkIds number[]/string[] will checked node ids
    props (same) (same)
    import { treeCheck } from "operation-tree-node";
    
    const treeData = [{ id: 1, name: "123", children: [{ id: 2, name: "2" }] }];
    const resultIds = treeCheck(treeData, [2], {
      id: "id",
      children: "children",
      parent: "parent"
    });
    console.log(resultIds);
    // [2, 1]
    • treeEach(data, callback, props) tree node each(like Array.prototype.forEach)

    recursive will break until callback is false.

    import { treeEach } from "operation-tree-node";
    
    const treeData1 = [{ id: 1, name: "1", children: [{ id: 2, name: "2" }] }];
    
    treeEach(treeData1, (node, index, arr, parent) => {
      console.log(node.name, index, arr, parent);
    });
    // '1', 0, [treeData], undefined
    // '2', 0, [treeData[0].children], [treeData[0]]
    
    // use children props
    const treeData2 = [{ id: 1, name: "1", child: [{ id: 2, name: "2" }] }];
    treeEach(treeData2, console.log, { children: "child" });
    • treeEachParent(data, callback, props) tree node each parent

    recursive will break until callback is false.

    arguments:

    name type description
    data (same) (same)
    callback (parent) => void/boolean parent: parent node, if callback false, skip parent.parent
    props (same) (same)
    import { treeEachParent } from "operation-tree-node";
    
    const treeData = [
      { id: 1, name: "123", children: [{ id: 2, name: "2", parent: null }] }
    ];
    treeData[0].children[0].parent = treeData[0];
    
    const names = [];
    treeEachParent(treeData[0].children, parent => !!names.push(parent.name));
    console.log(names);
    // ['123']
    • treeFilter(data, callback, props, isStrictly) tree node filter(like Array.prototype.filter)

    get a new data instead of change source.

    import { treeFilter } from "operation-tree-node";
    
    const treeData = [
      { id: 1, name: "1", child: [{ id: 2, name: "2" }] },
      { id: 3, name: "3" }
    ];
    
    const result = treeFilter(treeData, node => node.id === 2, {
      children: "child"
    });
    console.log(result);
    // [{ id: 1, name: '1', child: [{ id: 2, name: '2' }] }]
    • treeFind(data, callback, props) tree node find(like Array.prototype.find)

    recursive will break until found.

    import { treeFind } from "operation-tree-node";
    
    const treeData = [
      { id: 1, name: "1", children: [{ id: 2, name: "2" }] },
      { id: 1, name: "1", children: [{ id: 2, name: "2" }] }
    ];
    
    const find = treeFind(treeData, node => node.id === 2);
    console.log(find);
    // { id: 2, name: '2' }
    • treeFind(node, callback, props) tree node find parent
    import { treeFindParent } from "operation-tree-node";
    
    const treeData = [
      {
        id: 1,
        name: "123",
        parent: null,
        children: [{ id: 2, name: "2", parent: null, children: [] }]
      }
    ];
    treeData[0].children[0].parent = treeData[0];
    
    const find = treeFindParent(treeData[0].children[0], node => node.id === 1);
    console.log(find);
    // { id: 1, name: '123', children: ... }
    • treeMap(data, callback, props) tree node map(like Array.prototype.map)

    get a new data instead of change source.

    import { treeMap } from "operation-tree-node";
    
    const treeData = [{ id: 1, name: "1", children: [{ id: 2, name: "2" }] }];
    
    // tree node's +1
    const newData = treeMap(treeData, node => ({
      id: node.id + 1,
      name: node.name,
      ...(node.children ? { children: node.children } : {})
    }));
    console.log(newData);
    // [{ id: 2, name: '1', children: [{ id: 3, name: '2' }] }]
    • treeMerge(data, callback, props) tree node merge(same level)

    get a new data instead of change source.

    arguments:

    name type description
    data (same) (same)
    callback (currentNode, nextNode) => boolean currentNode/nextNode: tree node, compare with them
    props (same) (same)
    import { treeMerge } from "operation-tree-node";
    
    const treeData = [
      { id: 1, name: "1", type: "1", children: [{ id: 2, name: "2" }] },
      { id: 3, name: "3", type: "1", children: [{ id: 4, name: "4" }] }
    ];
    
    const result = treeMerge(
      treeData,
      (curr, next) => curr.type && curr.type === next.type
    );
    console.log(result);
    // [
    //   {
    //     id: 1,
    //     name: '1',
    //     type: '1',
    //     children: [{ id: 2, name: '2' }, { id: 4, name: '4' }]
    //   }
    // ]
    • treeSort(data, callback, props) tree node sort(like Array.prototype.sort)

    get a new data instead of change source.

    arguments:

    name type description
    data (same) (same)
    callback (currentNode, nextNode) => number currentNode/nextNode: tree node, compare with them
    props (same) (same)
    const treeData = [
      {
        id: 1,
        name: "1",
        children: [{ id: 3, name: "3" }, { id: 2, name: "2" }]
      }
    ];
    
    // 1,3,2 => 1,2,3
    const newData = treeSort(
      treeData,
      (currentNode, nextNode) => currentNode.id - nextNode.id
    );
    console.log(newData);
    // [
    //   {
    //     id: 1,
    //     name: '1',
    //     children: [{ id: 2, name: '2' }, { id: 3, name: '3' }]
    //   }
    // ]);
    • treeToFlatArray(data, callback, props) tree to flat array

    get a flat array and source data structure is not change.

    import { treeToFlatArray } from "operation-tree-node";
    
    const treeData = [{ id: 1, name: "1", children: [{ id: 2, name: "2" }] }];
    
    const result = treeToFlatArray(treeData);
    console.log(result);
    // [
    //   { id: 1, name: '1', children: [{ id: 2, name: '2' }] },
    //   { id: 2, name: '2' }
    // ]

    Install

    npm i operation-tree-node

    DownloadsWeekly Downloads

    77

    Version

    1.0.9

    License

    MIT

    Unpacked Size

    32.8 kB

    Total Files

    28

    Last publish

    Collaborators

    • yujinpan