Can I remove a redundant data structure wrapper from my nested array to nested json script?

Question

I wrote this script to convert a nested array with the structure below to a nested object with parent child relationships.

list = [
    ['lvl-1 item-1', 'lvl-2 item-1'],
    ['lvl-1 item-1', 'lvl-2 item-1', 'lvl-3 item-1'],
    ['lvl-1 item-1', 'lvl-2 item-1', 'lvl-3 item-2'],
    ['lvl-1 item-2', 'lvl-2 item-1', 'lvl-3 item-1'],
    ['lvl-1 item-2', 'lvl-2 item-2', 'lvl-3 item-2', 'lvl-4 item-1'],
];

It seems to do the trick, but in order to prime the script I've had to add data.children wrapper around the initial data structure. I'm not convinced it is needed, though I haven't been able to workout how to get rid of it.

Can anyone see anything I'm missing?

console.log(nestedArrayToJson(list));

function nestedArrayToJson(structure) {
    const top_item = '0';

    // This was added to behave like the child data structure.
    let data = {
        children: [
            {
                name: top_item,
                parent: null,
                children: [],
            }],
    };

    for(let i = 0; i < structure.length; i++) {
        let parents = [top_item];
        for(let j = 0; j < structure[i].length; j++) {
            let obj = data;
            for(parent of parents) {
                obj = obj.children.find(o => o.name === parent);
            }
            const name = structure[i][j];
            if(!obj.children.find(o => o.name === name)) {
                obj.children.push({
                    name,
                    parent,
                    children: [],
                });
            }
            parents.push(structure[i][j]);
        }
    }

    return data.children[0];
}

Sample Output

{
  "name": "0",
  "parent": null,
  "children": [
    {
      "name": "lvl-1 item-1",
      "parent": "0",
      "children": [
        {
          "name": "lvl-2 item-1",
          "parent": "lvl-1 item-1",
          "children": [
            {
              "name": "lvl-3 item-1",
              "parent": "lvl-2 item-1",
              "children": []
            },
            {
              "name": "lvl-3 item-2",
              "parent": "lvl-2 item-1",
              "children": []
            }
          ]
        }
      ]
    },
    {
      "name": "lvl-1 item-2",
      "parent": "0",
      "children": [
        {
          "name": "lvl-2 item-1",
          "parent": "lvl-1 item-2",
          "children": [
            {
              "name": "lvl-3 item-1",
              "parent": "lvl-2 item-1",
              "children": []
            }
          ]
        },
        {
          "name": "lvl-2 item-2",
          "parent": "lvl-1 item-2",
          "children": [
            {
              "name": "lvl-3 item-2",
              "parent": "lvl-2 item-2",
              "children": [
                {
                  "name": "lvl-4 item-1",
                  "parent": "lvl-3 item-2",
                  "children": []
                }
              ]
            }
          ]
        }
      ]
    }
  ]
}

Answer 1

The for loops can be cleaned up by extracting some functionality to named functions.

const node = (name, parent = null) => ({name, parent, children: []}) handles creating a node.

Nodes can then be added with addNode()

To search for the current next parent node findNamedNode()

If a node with the current name is found it moves down to the next node . If no node exists with the current name it is created.

function createTree(arr, topItem = 'Top') {
    const node = (name, parent = null) => ({name, parent, children: []});
    const addNode = (parent, child) => {
        parent.children.push(child);

        return child;
    };
    const findNamedNode = (name, parent) => {
        for(const child of parent.children) {
            if(child.name === name) { return child; }
            const found = findNamedNode(name, child);
            if(found) { return found; }
        }
    };

    const top = node(topItem);
    let current;

    for(const children of arr) {
        current = top;
        for(const name of children) {
            const found = findNamedNode(name, current);
            current = found ? found : addNode(current,
                node(name, current.name));
        }
    }

    return top;
}

Thanks to the help from @Blindman67 on Code Review.

https://codereview.stackexchange.com/questions/219418/convert-nested-array-of-values-to-a-tree-structure/