实现transform函数，将对象转成类似树结构的数组

[Rain120]

题目

function transform(values) {
  // ...
}

transform({
    0: {
        username: '0',
        department: 'A-B-C',
    },
    1: {
        username: '1',
        department: 'A-B-D',
    },
    2: {
        username: '2',
        department: 'A-X-Y',
    },
    3: {
        username: '2',
        department: 'A-C-B-D-Y',
    },
});
[
    {
        name: 'A',
        parent: '',
        path: 'A',
        children: [
            {
                name: '0',
                parent: 'A',
                path: 'A-B',
                children: [
                    {
                        name: '0',
                        parent: 'A-B',
                        path: 'A-B-C',
                        children: [],
                    },
                    {
                        name: '1',
                        parent: 'A-B',
                        path: 'A-B-D',
                        children: [],
                    },
                ],
            },
            {
                name: '2',
                parent: 'A',
                path: 'A-X',
                children: [
                    {
                        name: '2',
                        parent: 'A-X',
                        path: 'A-X-Y',
                        children: [],
                    },
                ],
            },
            {
                name: '2',
                parent: 'A',
                path: 'A-C',
                children: [
                    {
                        name: '2',
                        parent: 'A-C',
                        path: 'A-C-B',
                        children: [
                            {
                                name: '2',
                                parent: 'A-C-B',
                                path: 'A-C-B-D',
                                children: [
                                    {
                                        name: '2',
                                        parent: 'A-C-B-D',
                                        path: 'A-C-B-D-Y',
                                        children: [],
                                    },
                                ],
                            },
                        ],
                    },
                ],
            },
        ],
    },
];

[Rain120]

function transform(values) {
    const res = [];
    const arr = [];
    const pathPool = [];

    for (const key in values) {
        const {username, department} = values[key];
        const paths = department.split('-');

        for (let i = 0; i < paths.length; i++) {
            const path = paths[i];
            const curPath = paths.slice(0, i + 1).join('-');
            if (pathPool.includes(curPath)) {
                continue;
            }

            pathPool.push(curPath);

            obj.name = i === 0 ? path : username;
            obj.path = curPath;
            obj.parent = i < 1 ? '' : paths.slice(0, i).join('-');
            obj.children = [];

            arr.push(obj);
        }
    }

    const map = {};

    for (let item of arr) {
        map[item.path] = item;
    }

    for (let item of arr) {
        if (!item.parent) {
            res.push(item);
            continue;
        } else {
            const parent = map[item.parent];

            if (parent) {
                parent.children.push(item);
            }
        }
    }

    return res;
}