Javascript 按深度超过2级的条件合并嵌套对象

我有一个非常简单的对象数组：

[
{类别：'A'，级别：'Aa'，子级别：'Aaa'}，
{类别：'A'，级别：'Aa'，子级别：'Aab'}，
{类别：'A'，级别：'Ab'，子级别：'Abb'}，
{类别：'B'，级别：'Ac'，子级别：'Abc'}
]

子级别总是唯一的，级别和类别可以相同。
我想从该数组创建以下对象：

[
{ 
类别:"A",，
儿童：[
{
级别：“Aa”，
儿童：[
{
次级级别：“Aaa”
},
{
次级级别：“Aab”
}
]
},
{
级别：“Ab”，
儿童：[
{
次级：“Abb”
}
]
}
]
},
{ 
类别:"B",，
儿童：[
{
级别：“Ac”，
儿童：[
{
次级：“Abc”
}] }] }]

换句话说，如果有两个对象具有相同的类别，我想将

类别

合并为一个，并将其级别放入数组

子对象

。如果还有具有相同类别和级别的对象，则将相同级别合并为一个，并将子级别放置到相关数组

子级

使用
[].map
和
[].reduce
和各种循环，在数组中进行迭代并没有真正起作用。还尝试了lodash mergeWith和deepmerge，但子级别似乎对他们来说是不可见的

在深度超过2层的条件下构造对象的优雅方法是什么？
您只需要在原始数组上使用一个带有嵌套过滤器/映射的缩减器

const categories = base.reduce((accumulator, data) => {
  let category;

  if (!accumulator.find(d => d.category === data.category)) {
    category = {
      category: data.category,
      children: [],
    };

    base
      .filter(d => d.category === data.category)
      .map(d => {
        if (!category.children.find(c => c.level === d.level)) {
          category.children.push({ level: d.level, children: [] });
        }

        const level = category.children.find(c => c.level === d.level);

        if (!level.children.find(c => c.sublevel === d.sublevel)) {
          level.children.push({ sublevel: d.sublevel });
        }
      })


    accumulator.push(category);
  }

  return accumulator;
}, []);

我知道上帝是万能的，你又一次说明了这一点。非常感谢。